Java多线程核心机制全面解析

NEW → RUNNABLE：调用thread.start()（仅能触发一次，再次调用会抛IllegalThreadStateException）
RUNNABLE → BLOCKED：尝试获取synchronized锁失败
BLOCKED → RUNNABLE：其他线程释放synchronized锁，当前线程抢到锁
RUNNABLE → WAITING：调用object.wait()、thread.join()、LockSupport.park()
WAITING → RUNNABLE：其他线程调用object.notify()/notifyAll()、LockSupport.unpark()
RUNNABLE → TIMED_WAITING：调用Thread.sleep(long)、object.wait(long)、thread.join(long)
TIMED_WAITING → RUNNABLE：等待时间到、其他线程调用notify()/unpark()
RUNNABLE → TERMINATED：run()执行完毕、未捕获异常终止

// 1. 继承Thread类
class MyThread extends Thread {
    // 2. 重写run()：定义线程执行的任务（无返回值，不能抛受检异常）
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            // Thread.currentThread()：获取当前执行的线程对象
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep(500); // 模拟任务耗时，线程进入TIMED_WAITING状态
            } catch (InterruptedException e) {
                // 捕获中断异常（如其他线程调用interrupt()）
                System.out.println(Thread.currentThread().getName() + "被中断");
                return; // 中断后退出线程
            }
        }
    }
}
// 使用线程
public class ThreadCreate1 {
    public static void main(String[] args) {
        // 3. 创建线程对象
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        // 4. 设置线程名（便于调试）
        thread1.setName("线程A");
        thread2.setName("线程B");
        // 5. 启动线程（状态从NEW→RUNNABLE）
        thread1.start();
        thread2.start();
        // 注意：直接调用run()不会创建新线程，仅在主线程中执行
        // thread1.run(); // 错误用法
    }
}

// 1. 实现Runnable接口
class MyRunnable implements Runnable {
    // 2. 重写run()：定义任务（无返回值，不能抛受检异常）
    @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. 创建任务对象（任务与线程分离）
        MyRunnable task = new MyRunnable();
        // 4. 将任务传入Thread，启动线程（多个线程可共享同一个任务）
        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. 实现Callable接口（泛型指定返回值类型）
class MyCallable implements Callable<Integer> {
    private int num;
    public MyCallable(int num) {
        this.num = num;
    }
    // 2. 重写call()：有返回值，可抛受检异常
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= num; i++) {
            sum += i;
            Thread.sleep(100); // 模拟计算耗时
        }
        return sum; // 返回1~num的和
    }
}
// 使用线程
public class ThreadCreate3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 3. 创建Callable任务对象
        MyCallable task = new MyCallable(10);
        // 4. 用FutureTask包装Callable（FutureTask实现了Runnable，可传入Thread）
        FutureTask<Integer> futureTask = new FutureTask<>(task);
        // 5. 启动线程
        new Thread(futureTask, "计算线程").start();
        // 6. 获取任务结果（get()是阻塞方法，直到线程执行完毕返回结果）
        System.out.println("主线程等待计算结果...");
        Integer result = futureTask.get(); // 阻塞等待，直到call()返回
        System.out.println("1~10的和：" + result); // 输出：55
        // 其他FutureTask方法
        System.out.println("任务是否完成：" + futureTask.isDone()); // true
        System.out.println("任务是否取消：" + 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. 创建线程池（根据场景选择线程池类型）
        // 固定线程数线程池（适合CPU密集型任务）
        ExecutorService fixedPool = Executors.newFixedThreadPool(2);
        // 缓存线程池（适合IO密集型任务，线程空闲60秒后销毁）
        // ExecutorService cachedPool = Executors.newCachedThreadPool();
        // 单线程池（适合顺序执行任务）
        // ExecutorService singlePool = Executors.newSingleThreadExecutor();
        // 2. 提交Runnable任务（无返回值）
        fixedPool.submit(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + ": Runnable任务");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 3. 提交Callable任务（有返回值，返回Future对象）
        Future<Integer> future = fixedPool.submit(() -> {
            int sum = 0;
            for (int i = 1; i <= 5; i++) {
                sum += i;
                Thread.sleep(100);
            }
            return sum;
        });
        // 4. 获取Callable任务结果
        System.out.println("Callable任务结果：" + future.get()); // 输出：15
        // 5. 关闭线程池（重要！否则JVM不会退出）
        // shutdown()：不再接受新任务，等待已提交任务执行完毕后关闭
        fixedPool.shutdown();
        // shutdownNow()：立即关闭，尝试中断正在执行的任务（可能导致数据不一致）
        // fixedPool.shutdownNow();
    }
}

class VisibilityDemo {
    private boolean stopFlag = false; // 共享变量（无可见性保证）
    public void start() {
        new Thread(() -> {
            while (!stopFlag) { // 线程1读取的是CPU缓存中的false，即使主线程修改也无法看到
                // 循环执行
            }
            System.out.println("线程停止");
        }).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        stopFlag = true; // 主线程修改stopFlag为true，但线程1无法看到
        System.out.println("主线程已设置stopFlag为true");
    }
    public static void main(String[] args) {
        new VisibilityDemo().start(); // 线程1不会停止，陷入无限循环
    }
}

class AtomicityDemo {
    private int count = 0; // 共享变量（无原子性保证）
    // 非线程安全的方法
    public void increment() {
        count++; // 原子性问题：多线程下操作交错，导致计数不准确
    }
    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个线程各执行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();
        }
        // 等待所有线程执行完毕
        for (Thread thread : threads) {
            thread.join();
        }
        // 预期结果2000，实际结果可能小于2000（如1850）
        System.out.println("最终计数：" + demo.getCount());
    }
}

class OrderingDemo {
    private int a = 0;
    private boolean flag = false;
    // 线程1执行
    public void writer() {
        a = 1; // 指令1
        flag = true; // 指令2（可能被重排序到指令1之前）
    }
    // 线程2执行
    public void reader() {
        if (flag) { // 若flag=true，线程2认为a已被赋值为1
            System.out.println(a); // 可能输出0（指令2先执行，指令1未执行）
        }
    }
}

// 非静态同步方法（锁是this）
public synchronized void safeIncrement() {
    count++; // 原子操作
}
// 静态同步方法（锁是AtomicityDemo.class）
public static synchronized void staticSafeIncrement() {
    staticCount++;
}

public void safeIncrement() {
    synchronized (this) { // 锁对象为this（可替换为其他对象，如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;
    // 创建Lock对象（默认非公平锁，传入true创建公平锁）
    private final Lock lock = new ReentrantLock(true);
    public void safeIncrement() {
        lock.lock(); // 加锁（若锁被占用，线程进入WAITING状态，加入条件队列）
        try {
            count++; // 临界区代码（原子操作）
        } finally {
            lock.unlock(); // 释放锁（必须在finally中，避免异常导致锁未释放）
        }
    }
    // 支持中断的加锁（避免线程无限等待）
    public void safeIncrementWithInterrupt() throws InterruptedException {
        if (lock.tryLock(1000, java.util.concurrent.TimeUnit.MILLISECONDS)) { // 超时1秒
            try {
                count++;
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("获取锁超时");
        }
    }
    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++（等价于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("最终计数：" + demo.getCount()); // 输出：2000（准确）
    }
}

// 共享缓冲区（存储产品）
class Buffer {
    private int[] products = new int[5]; // 缓冲区大小为5
    private int count = 0; // 当前产品数量
    private int putIndex = 0; // 生产者放入产品的索引
    private int takeIndex = 0; // 消费者取出产品的索引
    // 生产者放入产品
    public synchronized void put(int product) throws InterruptedException {
        // 缓冲区满，等待消费者取出（用while避免虚假唤醒）
        while (count == products.length) {
            System.out.println("缓冲区满，生产者等待");
            wait(); // 释放锁，进入等待队列
        }
        // 放入产品
        products[putIndex] = product;
        putIndex = (putIndex + 1) % products.length;
        count++;
        System.out.println("生产者放入产品：" + product + "，当前数量：" + count);
        notify(); // 唤醒消费者（缓冲区有产品了）
    }
    // 消费者取出产品
    public synchronized void take() throws InterruptedException {
        // 缓冲区空，等待生产者放入
        while (count == 0) {
            System.out.println("缓冲区空，消费者等待");
            wait(); // 释放锁，进入等待队列
        }
        // 取出产品
        int product = products[takeIndex];
        takeIndex = (takeIndex + 1) % products.length;
        count--;
        System.out.println("消费者取出产品：" + product + "，当前数量：" + count);
        notify(); // 唤醒生产者（缓冲区有空位了）
    }
}
// 生产者线程
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); // 模拟生产耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
// 消费者线程
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); // 模拟消费耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
// 测试
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();
    // 创建两个Condition：生产者等待队列和消费者等待队列
    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("缓冲区满，生产者等待");
                producerCond.await(); // 生产者进入生产者等待队列
            }
            products[putIndex] = product;
            putIndex = (putIndex + 1) % products.length;
            count++;
            System.out.println("生产者放入产品：" + product + "，当前数量：" + count);
            consumerCond.signal(); // 仅唤醒消费者等待队列的线程（精准唤醒）
        } finally {
            lock.unlock();
        }
    }
    public int take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                System.out.println("缓冲区空，消费者等待");
                consumerCond.await(); // 消费者进入消费者等待队列
            }
            int product = products[takeIndex];
            takeIndex = (takeIndex + 1) % products.length;
            count--;
            System.out.println("消费者取出产品：" + product + "，当前数量：" + count);
            producerCond.signal(); // 仅唤醒生产者等待队列的线程
            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() + "执行任务");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown(); // 任务完成，倒计时减1
                }
            }, "任务线程" + i).start();
        }
        latch.await(); // 主线程等待，直到倒计时为0
        System.out.println("所有任务执行完毕，主线程继续");
    }
}

import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        int threadNum = 3;
        // 屏障动作：所有线程到达后执行
        CyclicBarrier barrier = new CyclicBarrier(threadNum, () -> {
            System.out.println("所有线程到达屏障，执行屏障动作");
        });
        for (int i = 0; i < threadNum; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "正在执行");
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println(Thread.currentThread().getName() + "到达屏障");
                    barrier.await(); // 等待其他线程到达
                    System.out.println(Thread.currentThread().getName() + "继续执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "线程" + i).start();
        }
    }
}

import java.util.concurrent.Semaphore;
public class SemaphoreDemo {
    public static void main(String[] args) {
        int permitNum = 2; // 允许同时访问的线程数
        Semaphore semaphore = new Semaphore(permitNum);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire(); // 获取许可（若无许可，线程阻塞）
                    System.out.println(Thread.currentThread().getName() + "获取许可，访问资源");
                    Thread.sleep(1000); // 模拟访问资源耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); // 释放许可
                    System.out.println(Thread.currentThread().getName() + "释放许可");
                }
            }, "线程" + i).start();
        }
    }
}

// 优化前：同步整个方法
public synchronized void process() {
    // 非临界区代码（无需同步）
    log();
    // 临界区代码（需同步）
    count++;
}
// 优化后：仅同步临界区
public void process() {
    // 非临界区代码（无需同步）
    log();
    synchronized (this) {
        // 临界区代码（需同步）
        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();
        }
    }
    // 写操作（排他）
    public void writeData(int data) {
        writeLock.lock();
        try {
            this.data = data;
        } finally {
            writeLock.unlock();
        }
    }
}

public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        // 执行任务逻辑
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // 恢复中断状态（否则后续循环无法感知中断）
            Thread.currentThread().interrupt();
            break; // 退出循环，终止线程
        }
    }
}

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