public class JoinDemo1 {
    // 共享變量存儲子線程的計算結(jié)果
    private static int sum = 0;

    public static void main(String[] args) throws InterruptedException {
        // 目標(biāo)線程：計算1-100的和
        Thread calcThread = new Thread(() -> {
            for (int i = 1; i <= 100; i++) {
                sum += i;
            }
            System.out.println("目標(biāo)線程（calcThread）：計算完成，sum=" + sum);
        });

        // 啟動目標(biāo)線程
        calcThread.start();
        // 當(dāng)前線程（主線程）等待目標(biāo)線程計算完成
        calcThread.join();

        // 當(dāng)前線程（主線程）使用目標(biāo)線程的結(jié)果
        System.out.println("當(dāng)前線程（主線程）：拿到結(jié)果，sum=" + sum);
    }
}

public class JoinDemo2 {
    public static void main(String[] args) throws InterruptedException {
        // 創(chuàng)建3個目標(biāo)線程（下載線程）
        Thread t1 = new Thread(() -> System.out.println("目標(biāo)線程（t1）：文件1下載完成"), "下載線程1");
        Thread t2 = new Thread(() -> System.out.println("目標(biāo)線程（t2）：文件2下載完成"), "下載線程2");
        Thread t3 = new Thread(() -> System.out.println("目標(biāo)線程（t3）：文件3下載完成"), "下載線程3");

        // 啟動所有目標(biāo)線程
        t1.start();
        t2.start();
        t3.start();

        // 當(dāng)前線程（主線程）等待所有目標(biāo)線程完成
        t1.join();
        t2.join();
        t3.join();

        // 當(dāng)前線程（主線程）匯總結(jié)果
        System.out.println("當(dāng)前線程（主線程）：所有文件下載完成，開始合并文件！");
    }
}

public class SleepDemo1 {
    public static void main(String[] args) {
        // 驗證碼倒計時60秒
        int count = 60;
        while (count > 0) {
            System.out.println("當(dāng)前線程（主線程）：驗證碼倒計時：" + count + "秒");
            try {
                // 當(dāng)前線程（主線程）暫停1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count--;
        }
        System.out.println("當(dāng)前線程（主線程）：驗證碼已過期，請重新獲??！");
    }
}

public class SleepDemo2 {
    public static void main(String[] args) {
        // 模擬一個持續(xù)運(yùn)行的監(jiān)控線程（當(dāng)前線程）
        Thread monitorThread = new Thread(() -> {
            while (true) {
                // 執(zhí)行監(jiān)控邏輯
                System.out.println("當(dāng)前線程（monitorThread）：監(jiān)控系統(tǒng)運(yùn)行中...");
                try {
                    // 當(dāng)前線程（monitorThread）每隔5秒監(jiān)控一次
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // 被中斷時退出循環(huán)
                    break;
                }
            }
        });
        monitorThread.start();
    }
}

public class WaitNotifyDemo {
    // 共享隊列（用數(shù)組模擬，容量為3）
    private static final int[] QUEUE = new int[3];
    // 隊列當(dāng)前元素個數(shù)
    private static int count = 0;
    // 鎖對象（所有線程共用同一個鎖）
    private static final Object LOCK = new Object();

    // 生產(chǎn)者線程：生產(chǎn)產(chǎn)品（往隊列加元素）
    static class Producer extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (LOCK) {
                    // 隊列滿，當(dāng)前線程（生產(chǎn)者）成為等待線程，等待消費(fèi)者喚醒
                    while (count == QUEUE.length) {
                        try {
                            System.out.println("當(dāng)前線程（生產(chǎn)者）：隊列滿，等待消費(fèi)者消費(fèi)...");
                            LOCK.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    // 生產(chǎn)產(chǎn)品
                    QUEUE[count] = (int) (Math.random() * 100);
                    System.out.println("當(dāng)前線程（生產(chǎn)者）：生產(chǎn)" + QUEUE[count]);
                    count++;
                    // 當(dāng)前線程（生產(chǎn)者）成為喚醒線程，喚醒等待的消費(fèi)者
                    LOCK.notifyAll();
                }
                // 模擬生產(chǎn)間隔
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 消費(fèi)者線程：消費(fèi)產(chǎn)品（從隊列取元素）
    static class Consumer extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (LOCK) {
                    // 隊列空，當(dāng)前線程（消費(fèi)者）成為等待線程，等待生產(chǎn)者喚醒
                    while (count == 0) {
                        try {
                            System.out.println("當(dāng)前線程（消費(fèi)者）：隊列空，等待生產(chǎn)者生產(chǎn)...");
                            LOCK.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    // 消費(fèi)產(chǎn)品
                    count--;
                    System.out.println("當(dāng)前線程（消費(fèi)者）：消費(fèi)" + QUEUE[count]);
                    // 當(dāng)前線程（消費(fèi)者）成為喚醒線程，喚醒等待的生產(chǎn)者
                    LOCK.notifyAll();
                }
                // 模擬消費(fèi)間隔
                try {
                    Thread.sleep(800);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        // 啟動1個生產(chǎn)者、1個消費(fèi)者
        new Producer().start();
        new Consumer().start();
    }
}

public class WaitNotifyDemo2 {
    // 初始化完成標(biāo)記
    private static boolean initDone = false;
    // 鎖對象
    private static final Object LOCK = new Object();

    public static void main(String[] args) {
        // 等待線程（當(dāng)前線程）：workThread子線程，等待初始化完成
        Thread workThread = new Thread(() -> {
            synchronized (LOCK) {
                // 等待初始化完成
                while (!initDone) {
                    try {
                        System.out.println("當(dāng)前線程（workThread）：等待初始化...");
                        LOCK.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("當(dāng)前線程（workThread）：初始化完成，開始工作！");
            }
        });
        workThread.start();

        // 喚醒線程（目標(biāo)線程）：主線程，執(zhí)行初始化并喚醒子線程
        try {
            Thread.sleep(2000); // 模擬初始化耗時
            synchronized (LOCK) {
                initDone = true;
                System.out.println("當(dāng)前線程（主線程）：初始化完成，喚醒子線程！");
                LOCK.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class YieldDemo {
    // 業(yè)務(wù)線程（高優(yōu)先級，處理核心邏輯）
    static class BusinessThread extends Thread {
        public BusinessThread() {
            // 設(shè)置高優(yōu)先級（1-10，默認(rèn)5）
            setPriority(Thread.MAX_PRIORITY);
        }

        @Override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                System.out.println("業(yè)務(wù)線程：處理訂單" + i);
            }
        }
    }

    // 統(tǒng)計線程（低優(yōu)先級，后臺統(tǒng)計）：當(dāng)前線程，執(zhí)行yield()讓步
    static class StatThread extends Thread {
        public StatThread() {
            // 設(shè)置低優(yōu)先級
            setPriority(Thread.MIN_PRIORITY);
        }

        @Override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                // 當(dāng)前線程（StatThread）主動讓步，讓業(yè)務(wù)線程先執(zhí)行
                Thread.yield();
                System.out.println("當(dāng)前線程（StatThread）：統(tǒng)計訂單" + i);
            }
        }
    }

    public static void main(String[] args) {
        new BusinessThread().start();
        new StatThread().start();
    }
}

import java.util.concurrent.locks.LockSupport;

public class LockSupportDemo1 {
    public static void main(String[] args) {
        // 阻塞線程（當(dāng)前線程）：workThread子線程
        Thread workThread = new Thread(() -> {
            System.out.println("當(dāng)前線程（workThread）：開始執(zhí)行，準(zhǔn)備阻塞...");
            // 當(dāng)前線程（workThread）阻塞自身
            LockSupport.park();
            System.out.println("當(dāng)前線程（workThread）：被喚醒，繼續(xù)執(zhí)行！");
        }, "工作線程");
        workThread.start();

        // 喚醒線程（主線程）：延遲2秒后喚醒目標(biāo)線程（workThread）
        try {
            Thread.sleep(2000);
            System.out.println("當(dāng)前線程（主線程）：喚醒目標(biāo)線程（workThread）！");
            LockSupport.unpark(workThread);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.locks.LockSupport;

public class LockSupportDemo2 {
    public static void main(String[] args) {
        // 阻塞線程（當(dāng)前線程）：workThread子線程
        Thread workThread = new Thread(() -> {
            // 先被unpark，再park（不會阻塞）
            System.out.println("當(dāng)前線程（workThread）：準(zhǔn)備阻塞...");
            LockSupport.park();
            System.out.println("當(dāng)前線程（workThread）：執(zhí)行完成！");
        });

        // 喚醒線程（主線程）：先執(zhí)行unpark，喚醒目標(biāo)線程（workThread）
        LockSupport.unpark(workThread);
        System.out.println("當(dāng)前線程（主線程）：先執(zhí)行unpark()，喚醒目標(biāo)線程（workThread）");

        // 啟動阻塞線程
        workThread.start();
    }
}