// 1. 自定義線程類，繼承Thread
public class MyThread extends Thread {
    // 2. 重寫run()方法，線程執(zhí)行的邏輯寫在這里
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            // Thread.currentThread().getName() 獲取當(dāng)前線程名
            System.out.println(Thread.currentThread().getName() + "：執(zhí)行了" + i);
        }
    }
    public static void main(String[] args) {
        // 3. 創(chuàng)建線程對(duì)象，設(shè)置線程名
        MyThread t1 = new MyThread();
        t1.setName("線程1");
        MyThread t2 = new MyThread();
        t2.setName("線程2");
        // 4. 啟動(dòng)線程：調(diào)用start()
        t1.start();
        t2.start();
        // 主線程也執(zhí)行邏輯，對(duì)比看多線程效果
        for (int i = 0; i < 5; i++) {
            System.out.println("主線程：執(zhí)行了" + i);
        }
    }
}

// 1. 自定義任務(wù)類，實(shí)現(xiàn)Runnable接口
public class MyRunnable implements Runnable {
    // 2. 重寫run()方法，編寫任務(wù)邏輯
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "：執(zhí)行了" + i);
        }
    }
    public static void main(String[] args) {
        // 3. 創(chuàng)建任務(wù)對(duì)象
        MyRunnable task = new MyRunnable();
        // 4. 把任務(wù)傳給Thread，創(chuàng)建線程對(duì)象
        Thread t1 = new Thread(task, "線程1");
        Thread t2 = new Thread(task, "線程2");
        // 5. 啟動(dòng)線程
        t1.start();
        t2.start();
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
// 1. 自定義任務(wù)類，實(shí)現(xiàn)Callable接口，指定泛型為返回值類型（Integer）
public class MyCallable implements Callable<Integer> {
    // 2. 重寫call()方法，有返回值，可拋異常
    @Override
    public Integer call() throws Exception {
        // 模擬計(jì)算：1-5的和
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
            System.out.println(Thread.currentThread().getName() + "：計(jì)算中，i=" + i);
        }
        return sum; // 返回計(jì)算結(jié)果
    }
    public static void main(String[] args) throws Exception {
        // 3. 創(chuàng)建Callable任務(wù)對(duì)象
        MyCallable callable = new MyCallable();
        // 4. 用FutureTask封裝任務(wù)，用于獲取返回值
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        // 5. 把FutureTask傳給Thread，創(chuàng)建線程并啟動(dòng)
        Thread t = new Thread(futureTask, "計(jì)算線程");
        t.start();
        // 6. 獲取線程執(zhí)行結(jié)果：get()方法會(huì)阻塞，直到線程執(zhí)行完成
        Integer result = futureTask.get();
        System.out.println(t.getName() + "執(zhí)行結(jié)果：1-5的和=" + result);
    }
}

public class ThreadMethodDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(1000); // 休眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "：執(zhí)行" + i);
            }
        }, "休眠線程");
        t.start();
        t.join(); // 主線程等待t執(zhí)行完再執(zhí)行
        System.out.println("主線程：執(zhí)行完成，休眠線程已結(jié)束");
    }
}

// 售票任務(wù)類，實(shí)現(xiàn)Runnable
public class TicketRunnable implements Runnable {
    // 共享資源：10張票（多個(gè)線程共用這個(gè)變量）
    private int ticketNum = 10;
    @Override
    public void run() {
        // 循環(huán)賣票
        while (true) {
            // 有票就賣
            if (ticketNum > 0) {
                try {
                    Thread.sleep(500); // 模擬選座、打印票的耗時(shí)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "賣出了1張票，剩余：" + --ticketNum);
            } else {
                // 無票就退出
                break;
            }
        }
    }
    public static void main(String[] args) {
        // 一個(gè)任務(wù)對(duì)象，3個(gè)線程共享
        TicketRunnable task = new TicketRunnable();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

synchronized(鎖對(duì)象) {
    // 操作共享資源的代碼塊（臨界區(qū)）
}

public class TicketSyncBlock implements Runnable {
    private int ticketNum = 10;
    // 鎖對(duì)象：多個(gè)線程共用同一個(gè)
    private Object lock = new Object();
    @Override
    public void run() {
        while (true) {
            // 同步代碼塊：加鎖，操作共享資源的代碼排隊(duì)執(zhí)行
            synchronized (lock) {
                if (ticketNum > 0) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "賣出了1張票，剩余：" + --ticketNum);
                } else {
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {
        TicketSyncBlock task = new TicketSyncBlock();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

public class TicketSyncMethod implements Runnable {
    private int ticketNum = 10;
    @Override
    public void run() {
        while (true) {
            // 調(diào)用同步方法
            if (!sellTicket()) {
                break;
            }
        }
    }
    // 同步方法：synchronized修飾，操作共享資源的代碼
    private synchronized boolean sellTicket() {
        if (ticketNum > 0) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "賣出了1張票，剩余：" + --ticketNum);
            return true;
        } else {
            return false;
        }
    }
    public static void main(String[] args) {
        TicketSyncMethod task = new TicketSyncMethod();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

import java.util.concurrent.locks.ReentrantLock;
public class TicketLock implements Runnable {
    private int ticketNum = 10;
    // 創(chuàng)建Lock鎖對(duì)象，可重入鎖
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            // 手動(dòng)加鎖
            lock.lock();
            try {
                // 操作共享資源的代碼
                if (ticketNum > 0) {
                    Thread.sleep(500);
                    System.out.println(Thread.currentThread().getName() + "賣出了1張票，剩余：" + --ticketNum);
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 手動(dòng)釋放鎖，放在finally中，保證一定執(zhí)行
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        TicketLock task = new TicketLock();
        new Thread(task, "窗口1").start();
        new Thread(task, "窗口2").start();
        new Thread(task, "窗口3").start();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolRunnable {
    public static void main(String[] args) {
        // 1. 創(chuàng)建固定線程池：核心線程數(shù)為2
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //使用線程池的實(shí)現(xiàn)類ThreadPoolExecutor創(chuàng)建線程池對(duì)象。（有七個(gè)參數(shù)）
        //ExecutorService pool = new ThreadPoolExecutor(
        //        2,//核心線程數(shù)
        //        2,//最大線程數(shù)
        //        0,//線程空閑時(shí)間
        //        TimeUnit.SECONDS,//時(shí)間單位
        //        new ArrayBlockingQueue<>(2),//任務(wù)隊(duì)列
        //        Executors.defaultThreadFactory(),//線程工廠對(duì)象
        //        new ThreadPoolExecutor.AbortPolicy()//拒絕策略
        //);
        // 2. 提交Runnable任務(wù)給線程池
        pool.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println(Thread.currentThread().getName() + "執(zhí)行Runnable任務(wù)：" + i);
                }
            }
        });
        pool.submit(() -> { // Lambda簡(jiǎn)化Runnable
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "執(zhí)行Lambda任務(wù)：" + i);
            }
        });
        // 3. 關(guān)閉線程池：shutdown()等待任務(wù)執(zhí)行完再關(guān)閉，shutdownNow()立即關(guān)閉
        pool.shutdown();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadPoolCallable {
    public static void main(String[] args) throws Exception {
        // 1. 創(chuàng)建固定線程池，核心線程數(shù)1
        ExecutorService pool = Executors.newFixedThreadPool(1);
        // 2. 提交Callable任務(wù)，F(xiàn)uture接收返回值
        Future<Integer> future = pool.submit(() -> {
            // 計(jì)算1-10的和
            int sum = 0;
            for (int i = 1; i <= 10; i++) {
                sum += i;
            }
            return sum;
        });
        // 3. 獲取返回值
        Integer result = future.get();
        System.out.println("Callable任務(wù)執(zhí)行結(jié)果：1-10的和=" + result);
        // 4. 關(guān)閉線程池
        pool.shutdown();
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledThreadPoolDemo {
    public static void main(String[] args) {
        // 創(chuàng)建定時(shí)線程池，核心線程數(shù)2
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        // 1. 延遲執(zhí)行：延遲1秒后執(zhí)行一次任務(wù)
        pool.schedule(() -> {
            System.out.println(Thread.currentThread().getName() + "：延遲1秒執(zhí)行");
        }, 1, TimeUnit.SECONDS);
        // 2. 定時(shí)執(zhí)行：延遲2秒后，每3秒執(zhí)行一次任務(wù)
        pool.scheduleAtFixedRate(() -> {
            System.out.println(Thread.currentThread().getName() + "：定時(shí)執(zhí)行，每3秒一次");
        }, 2, 3, TimeUnit.SECONDS);
    }
}