NEW → RUNNABLE：調(diào)用thread.start()（僅能觸發(fā)一次，再次調(diào)用會(huì)拋IllegalThreadStateException）
RUNNABLE → BLOCKED：嘗試獲取synchronized鎖失敗
BLOCKED → RUNNABLE：其他線程釋放synchronized鎖，當(dāng)前線程搶到鎖
RUNNABLE → WAITING：調(diào)用object.wait()、thread.join()、LockSupport.park()
WAITING → RUNNABLE：其他線程調(diào)用object.notify()/notifyAll()、LockSupport.unpark()
RUNNABLE → TIMED_WAITING：調(diào)用Thread.sleep(long)、object.wait(long)、thread.join(long)
TIMED_WAITING → RUNNABLE：等待時(shí)間到、其他線程調(diào)用notify()/unpark()
RUNNABLE → TERMINATED：run()執(zhí)行完畢、未捕獲異常終止

// 1. 繼承Thread類
class MyThread extends Thread {
    // 2. 重寫(xiě)run()：定義線程執(zhí)行的任務(wù)（無(wú)返回值，不能拋受檢異常）
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            // Thread.currentThread()：獲取當(dāng)前執(zhí)行的線程對(duì)象
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep(500); // 模擬任務(wù)耗時(shí)，線程進(jìn)入TIMED_WAITING狀態(tài)
            } catch (InterruptedException e) {
                // 捕獲中斷異常（如其他線程調(diào)用interrupt()）
                System.out.println(Thread.currentThread().getName() + "被中斷");
                return; // 中斷后退出線程
            }
        }
    }
}
// 使用線程
public class ThreadCreate1 {
    public static void main(String[] args) {
        // 3. 創(chuàng)建線程對(duì)象
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        // 4. 設(shè)置線程名（便于調(diào)試）
        thread1.setName("線程A");
        thread2.setName("線程B");
        // 5. 啟動(dòng)線程（狀態(tài)從NEW→RUNNABLE）
        thread1.start();
        thread2.start();
        // 注意：直接調(diào)用run()不會(huì)創(chuàng)建新線程，僅在主線程中執(zhí)行
        // thread1.run(); // 錯(cuò)誤用法
    }
}

// 1. 實(shí)現(xiàn)Runnable接口
class MyRunnable implements Runnable {
    // 2. 重寫(xiě)run()：定義任務(wù)（無(wú)返回值，不能拋受檢異常）
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
// 使用線程
public class ThreadCreate2 {
    public static void main(String[] args) {
        // 3. 創(chuàng)建任務(wù)對(duì)象（任務(wù)與線程分離）
        MyRunnable task = new MyRunnable();
        // 4. 將任務(wù)傳入Thread，啟動(dòng)線程（多個(gè)線程可共享同一個(gè)任務(wù)）
        Thread thread1 = new Thread(task, "線程C");
        Thread thread2 = new Thread(task, "線程D");
        thread1.start();
        thread2.start();
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
// 1. 實(shí)現(xiàn)Callable接口（泛型指定返回值類型）
class MyCallable implements Callable<Integer> {
    private int num;
    public MyCallable(int num) {
        this.num = num;
    }
    // 2. 重寫(xiě)call()：有返回值，可拋受檢異常
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= num; i++) {
            sum += i;
            Thread.sleep(100); // 模擬計(jì)算耗時(shí)
        }
        return sum; // 返回1~num的和
    }
}
// 使用線程
public class ThreadCreate3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 3. 創(chuàng)建Callable任務(wù)對(duì)象
        MyCallable task = new MyCallable(10);
        // 4. 用FutureTask包裝Callable（FutureTask實(shí)現(xiàn)了Runnable，可傳入Thread）
        FutureTask<Integer> futureTask = new FutureTask<>(task);
        // 5. 啟動(dòng)線程
        new Thread(futureTask, "計(jì)算線程").start();
        // 6. 獲取任務(wù)結(jié)果（get()是阻塞方法，直到線程執(zhí)行完畢返回結(jié)果）
        System.out.println("主線程等待計(jì)算結(jié)果...");
        Integer result = futureTask.get(); // 阻塞等待，直到call()返回
        System.out.println("1~10的和：" + result); // 輸出：55
        // 其他FutureTask方法
        System.out.println("任務(wù)是否完成：" + futureTask.isDone()); // true
        System.out.println("任務(wù)是否取消：" + futureTask.isCancelled()); // false
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadPoolCreate {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1. 創(chuàng)建線程池（根據(jù)場(chǎng)景選擇線程池類型）
        // 固定線程數(shù)線程池（適合CPU密集型任務(wù)）
        ExecutorService fixedPool = Executors.newFixedThreadPool(2);
        // 緩存線程池（適合IO密集型任務(wù)，線程空閑60秒后銷毀）
        // ExecutorService cachedPool = Executors.newCachedThreadPool();
        // 單線程池（適合順序執(zhí)行任務(wù)）
        // ExecutorService singlePool = Executors.newSingleThreadExecutor();
        // 2. 提交Runnable任務(wù)（無(wú)返回值）
        fixedPool.submit(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + ": Runnable任務(wù)");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 3. 提交Callable任務(wù)（有返回值，返回Future對(duì)象）
        Future<Integer> future = fixedPool.submit(() -> {
            int sum = 0;
            for (int i = 1; i <= 5; i++) {
                sum += i;
                Thread.sleep(100);
            }
            return sum;
        });
        // 4. 獲取Callable任務(wù)結(jié)果
        System.out.println("Callable任務(wù)結(jié)果：" + future.get()); // 輸出：15
        // 5. 關(guān)閉線程池（重要！否則JVM不會(huì)退出）
        // shutdown()：不再接受新任務(wù)，等待已提交任務(wù)執(zhí)行完畢后關(guān)閉
        fixedPool.shutdown();
        // shutdownNow()：立即關(guān)閉，嘗試中斷正在執(zhí)行的任務(wù)（可能導(dǎo)致數(shù)據(jù)不一致）
        // fixedPool.shutdownNow();
    }
}

class VisibilityDemo {
    private boolean stopFlag = false; // 共享變量（無(wú)可見(jiàn)性保證）
    public void start() {
        new Thread(() -> {
            while (!stopFlag) { // 線程1讀取的是CPU緩存中的false，即使主線程修改也無(wú)法看到
                // 循環(huán)執(zhí)行
            }
            System.out.println("線程停止");
        }).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        stopFlag = true; // 主線程修改stopFlag為true，但線程1無(wú)法看到
        System.out.println("主線程已設(shè)置stopFlag為true");
    }
    public static void main(String[] args) {
        new VisibilityDemo().start(); // 線程1不會(huì)停止，陷入無(wú)限循環(huán)
    }
}

class AtomicityDemo {
    private int count = 0; // 共享變量（無(wú)原子性保證）
    // 非線程安全的方法
    public void increment() {
        count++; // 原子性問(wèn)題：多線程下操作交錯(cuò)，導(dǎo)致計(jì)數(shù)不準(zhǔn)確
    }
    public int getCount() {
        return count;
    }
    public static void main(String[] args) throws InterruptedException {
        AtomicityDemo demo = new AtomicityDemo();
        int threadNum = 2;
        Thread[] threads = new Thread[threadNum];
        // 2個(gè)線程各執(zhí)行1000次increment()
        for (int i = 0; i < threadNum; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    demo.increment();
                }
            });
            threads[i].start();
        }
        // 等待所有線程執(zhí)行完畢
        for (Thread thread : threads) {
            thread.join();
        }
        // 預(yù)期結(jié)果2000，實(shí)際結(jié)果可能小于2000（如1850）
        System.out.println("最終計(jì)數(shù)：" + demo.getCount());
    }
}

class OrderingDemo {
    private int a = 0;
    private boolean flag = false;
    // 線程1執(zhí)行
    public void writer() {
        a = 1; // 指令1
        flag = true; // 指令2（可能被重排序到指令1之前）
    }
    // 線程2執(zhí)行
    public void reader() {
        if (flag) { // 若flag=true，線程2認(rèn)為a已被賦值為1
            System.out.println(a); // 可能輸出0（指令2先執(zhí)行，指令1未執(zhí)行）
        }
    }
}

// 非靜態(tài)同步方法（鎖是this）
public synchronized void safeIncrement() {
    count++; // 原子操作
}
// 靜態(tài)同步方法（鎖是AtomicityDemo.class）
public static synchronized void staticSafeIncrement() {
    staticCount++;
}

public void safeIncrement() {
    synchronized (this) { // 鎖對(duì)象為this（可替換為其他對(duì)象，如private final Object lock = new Object()）
        count++;
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class LockDemo {
    private int count = 0;
    // 創(chuàng)建Lock對(duì)象（默認(rèn)非公平鎖，傳入true創(chuàng)建公平鎖）
    private final Lock lock = new ReentrantLock(true);
    public void safeIncrement() {
        lock.lock(); // 加鎖（若鎖被占用，線程進(jìn)入WAITING狀態(tài)，加入條件隊(duì)列）
        try {
            count++; // 臨界區(qū)代碼（原子操作）
        } finally {
            lock.unlock(); // 釋放鎖（必須在finally中，避免異常導(dǎo)致鎖未釋放）
        }
    }
    // 支持中斷的加鎖（避免線程無(wú)限等待）
    public void safeIncrementWithInterrupt() throws InterruptedException {
        if (lock.tryLock(1000, java.util.concurrent.TimeUnit.MILLISECONDS)) { // 超時(shí)1秒
            try {
                count++;
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("獲取鎖超時(shí)");
        }
    }
    public int getCount() {
        return count;
    }
}

import java.util.concurrent.atomic.AtomicInteger;
class AtomicDemo {
    // 原子類：保證count++是原子操作
    private final AtomicInteger count = new AtomicInteger(0);
    public void safeIncrement() {
        count.incrementAndGet(); // 原子性的count++（等價(jià)于count = count + 1）
    }
    // 其他原子操作
    public void add() {
        count.addAndGet(5); // 原子性的count += 5
    }
    public int getCount() {
        return count.get();
    }
    public static void main(String[] args) throws InterruptedException {
        AtomicDemo demo = new AtomicDemo();
        Thread[] threads = new Thread[2];
        for (int i = 0; i < 2; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    demo.safeIncrement();
                }
            });
            threads[i].start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
        System.out.println("最終計(jì)數(shù)：" + demo.getCount()); // 輸出：2000（準(zhǔn)確）
    }
}

// 共享緩沖區(qū)（存儲(chǔ)產(chǎn)品）
class Buffer {
    private int[] products = new int[5]; // 緩沖區(qū)大小為5
    private int count = 0; // 當(dāng)前產(chǎn)品數(shù)量
    private int putIndex = 0; // 生產(chǎn)者放入產(chǎn)品的索引
    private int takeIndex = 0; // 消費(fèi)者取出產(chǎn)品的索引
    // 生產(chǎn)者放入產(chǎn)品
    public synchronized void put(int product) throws InterruptedException {
        // 緩沖區(qū)滿，等待消費(fèi)者取出（用while避免虛假喚醒）
        while (count == products.length) {
            System.out.println("緩沖區(qū)滿，生產(chǎn)者等待");
            wait(); // 釋放鎖，進(jìn)入等待隊(duì)列
        }
        // 放入產(chǎn)品
        products[putIndex] = product;
        putIndex = (putIndex + 1) % products.length;
        count++;
        System.out.println("生產(chǎn)者放入產(chǎn)品：" + product + "，當(dāng)前數(shù)量：" + count);
        notify(); // 喚醒消費(fèi)者（緩沖區(qū)有產(chǎn)品了）
    }
    // 消費(fèi)者取出產(chǎn)品
    public synchronized void take() throws InterruptedException {
        // 緩沖區(qū)空，等待生產(chǎn)者放入
        while (count == 0) {
            System.out.println("緩沖區(qū)空，消費(fèi)者等待");
            wait(); // 釋放鎖，進(jìn)入等待隊(duì)列
        }
        // 取出產(chǎn)品
        int product = products[takeIndex];
        takeIndex = (takeIndex + 1) % products.length;
        count--;
        System.out.println("消費(fèi)者取出產(chǎn)品：" + product + "，當(dāng)前數(shù)量：" + count);
        notify(); // 喚醒生產(chǎn)者（緩沖區(qū)有空位了）
    }
}
// 生產(chǎn)者線程
class Producer extends Thread {
    private Buffer buffer;
    public Producer(Buffer buffer) {
        this.buffer = buffer;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            try {
                buffer.put(i);
                Thread.sleep(500); // 模擬生產(chǎn)耗時(shí)
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
// 消費(fèi)者線程
class Consumer extends Thread {
    private Buffer buffer;
    public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            try {
                buffer.take();
                Thread.sleep(800); // 模擬消費(fèi)耗時(shí)
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
// 測(cè)試
public class WaitNotifyDemo {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();
        new Producer(buffer).start();
        new Consumer(buffer).start();
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class ConditionBuffer {
    private int[] products = new int[5];
    private int count = 0;
    private int putIndex = 0;
    private int takeIndex = 0;
    private final Lock lock = new ReentrantLock();
    // 創(chuàng)建兩個(gè)Condition：生產(chǎn)者等待隊(duì)列和消費(fèi)者等待隊(duì)列
    private final Condition producerCond = lock.newCondition();
    private final Condition consumerCond = lock.newCondition();
    public void put(int product) throws InterruptedException {
        lock.lock();
        try {
            while (count == products.length) {
                System.out.println("緩沖區(qū)滿，生產(chǎn)者等待");
                producerCond.await(); // 生產(chǎn)者進(jìn)入生產(chǎn)者等待隊(duì)列
            }
            products[putIndex] = product;
            putIndex = (putIndex + 1) % products.length;
            count++;
            System.out.println("生產(chǎn)者放入產(chǎn)品：" + product + "，當(dāng)前數(shù)量：" + count);
            consumerCond.signal(); // 僅喚醒消費(fèi)者等待隊(duì)列的線程（精準(zhǔn)喚醒）
        } finally {
            lock.unlock();
        }
    }
    public int take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                System.out.println("緩沖區(qū)空，消費(fèi)者等待");
                consumerCond.await(); // 消費(fèi)者進(jìn)入消費(fèi)者等待隊(duì)列
            }
            int product = products[takeIndex];
            takeIndex = (takeIndex + 1) % products.length;
            count--;
            System.out.println("消費(fèi)者取出產(chǎn)品：" + product + "，當(dāng)前數(shù)量：" + count);
            producerCond.signal(); // 僅喚醒生產(chǎn)者等待隊(duì)列的線程
            return product;
        } finally {
            lock.unlock();
        }
    }
}

import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        int taskNum = 3;
        CountDownLatch latch = new CountDownLatch(taskNum);
        for (int i = 0; i < taskNum; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "執(zhí)行任務(wù)");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown(); // 任務(wù)完成，倒計(jì)時(shí)減1
                }
            }, "任務(wù)線程" + i).start();
        }
        latch.await(); // 主線程等待，直到倒計(jì)時(shí)為0
        System.out.println("所有任務(wù)執(zhí)行完畢，主線程繼續(xù)");
    }
}

import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        int threadNum = 3;
        // 屏障動(dòng)作：所有線程到達(dá)后執(zhí)行
        CyclicBarrier barrier = new CyclicBarrier(threadNum, () -> {
            System.out.println("所有線程到達(dá)屏障，執(zhí)行屏障動(dòng)作");
        });
        for (int i = 0; i < threadNum; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "正在執(zhí)行");
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println(Thread.currentThread().getName() + "到達(dá)屏障");
                    barrier.await(); // 等待其他線程到達(dá)
                    System.out.println(Thread.currentThread().getName() + "繼續(xù)執(zhí)行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "線程" + i).start();
        }
    }
}

import java.util.concurrent.Semaphore;
public class SemaphoreDemo {
    public static void main(String[] args) {
        int permitNum = 2; // 允許同時(shí)訪問(wèn)的線程數(shù)
        Semaphore semaphore = new Semaphore(permitNum);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire(); // 獲取許可（若無(wú)許可，線程阻塞）
                    System.out.println(Thread.currentThread().getName() + "獲取許可，訪問(wèn)資源");
                    Thread.sleep(1000); // 模擬訪問(wèn)資源耗時(shí)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); // 釋放許可
                    System.out.println(Thread.currentThread().getName() + "釋放許可");
                }
            }, "線程" + i).start();
        }
    }
}

// 優(yōu)化前：同步整個(gè)方法
public synchronized void process() {
    // 非臨界區(qū)代碼（無(wú)需同步）
    log();
    // 臨界區(qū)代碼（需同步）
    count++;
}
// 優(yōu)化后：僅同步臨界區(qū)
public void process() {
    // 非臨界區(qū)代碼（無(wú)需同步）
    log();
    synchronized (this) {
        // 臨界區(qū)代碼（需同步）
        count++;
    }
}

import java.util.concurrent.locks.ReentrantReadWriteLock;
class ReadWriteLockDemo {
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
    private int data;
    // 讀操作（共享）
    public int readData() {
        readLock.lock();
        try {
            return data;
        } finally {
            readLock.unlock();
        }
    }
    // 寫(xiě)操作（排他）
    public void writeData(int data) {
        writeLock.lock();
        try {
            this.data = data;
        } finally {
            writeLock.unlock();
        }
    }
}

public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        // 執(zhí)行任務(wù)邏輯
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // 恢復(fù)中斷狀態(tài)（否則后續(xù)循環(huán)無(wú)法感知中斷）
            Thread.currentThread().interrupt();
            break; // 退出循環(huán)，終止線程
        }
    }
}

public class ThreadLocalDemo {
    private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();
    public void process() {
        try {
            threadLocal.set("線程私有數(shù)據(jù)");
            // 使用數(shù)據(jù)...
        } finally {
            threadLocal.remove(); // 清除value，避免泄漏
        }
    }
}