Java 多线程完全指南

Java 多线程完全指南

目录

1. 多线程基础
2. 线程创建方式
3. 线程生命周期
4. 线程控制
5. 线程同步
6. 线程通信
7. 锁机制
8. 线程池
9. 并发工具类
10. 原子类
11. 并发集合
12. CompletableFuture
13. 实战案例
14. 最佳实践

---

1. 多线程基础

1.1 进程与线程

进程（Process）：
- 操作系统分配资源的基本单位
- 拥有独立的内存空间
- 进程间通信开销大

线程（Thread）：
- CPU 调度的基本单位
- 共享进程的内存空间
- 线程间通信开销小
- 一个进程可以包含多个线程

1.2 并发与并行

并发（Concurrency）：
- 多个任务交替执行
- 单核 CPU 通过时间片轮转实现
- 宏观上同时，微观上交替

并行（Parallelism）：
- 多个任务同时执行
- 需要多核 CPU 支持
- 真正的同时执行

1.3 多线程的优势

1. 提高 CPU 利用率
2. 提高程序响应速度
3. 简化程序结构
4. 充分利用多核处理器

1.4 多线程的挑战

1. 线程安全问题
2. 死锁问题
3. 资源竞争
4. 上下文切换开销
5. 调试困难

---

2. 线程创建方式

2.1 继承 Thread 类

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

// 使用
MyThread thread = new MyThread();
thread.setName("MyThread");
thread.start();  // 启动线程，不是 run()

2.2 实现 Runnable 接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

// 使用
Thread thread = new Thread(new MyRunnable(), "MyRunnable");
thread.start();

// Lambda 表达式
Thread thread2 = new Thread(() -> {
    System.out.println("Lambda 线程");
});
thread2.start();

2.3 实现 Callable 接口

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

// 使用 FutureTask
FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();

// 获取结果（阻塞）
Integer result = futureTask.get();
System.out.println("结果: " + result);

// 带超时的获取
Integer result2 = futureTask.get(1, TimeUnit.SECONDS);

2.4 使用线程池

ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交 Runnable
executor.execute(() -> {
    System.out.println("Runnable 任务");
});

// 提交 Callable
Future<String> future = executor.submit(() -> {
    return "Callable 结果";
});
String result = future.get();

executor.shutdown();

2.5 创建方式对比

方式	优点	缺点
继承 Thread	简单直接	无法继承其他类
实现 Runnable	可继承其他类，适合资源共享	无返回值
实现 Callable	有返回值，可抛出异常	稍复杂
线程池	复用线程，管理方便	需要正确配置

---

3. 线程生命周期

3.1 线程状态

public enum State {
    NEW,           // 新建：线程被创建但未启动
    RUNNABLE,      // 可运行：正在运行或等待 CPU 时间片
    BLOCKED,       // 阻塞：等待获取锁
    WAITING,       // 等待：无限期等待其他线程
    TIMED_WAITING, // 超时等待：有时限的等待
    TERMINATED     // 终止：线程执行完毕
}

3.2 状态转换图

        start()
NEW ─────────────> RUNNABLE
                      │
         ┌────────────┼────────────┐
         │            │            │
         ▼            ▼            ▼
     BLOCKED      WAITING    TIMED_WAITING
         │            │            │
         └────────────┼────────────┘
                      │
                      ▼
                 TERMINATED

3.3 状态转换示例

Thread thread = new Thread(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

System.out.println(thread.getState());  // NEW

thread.start();
System.out.println(thread.getState());  // RUNNABLE

Thread.sleep(100);
System.out.println(thread.getState());  // TIMED_WAITING

thread.join();
System.out.println(thread.getState());  // TERMINATED

3.4 获取线程状态

Thread thread = new Thread(() -> {
    // 线程逻辑
});

// 获取状态
Thread.State state = thread.getState();

// 判断是否存活
boolean alive = thread.isAlive();

// 判断是否中断
boolean interrupted = thread.isInterrupted();

---

4. 线程控制

4.1 线程休眠

// 休眠指定毫秒
Thread.sleep(1000);

// 休眠指定时间
TimeUnit.SECONDS.sleep(1);
TimeUnit.MILLISECONDS.sleep(500);

4.2 线程让步

// 让出 CPU 时间片，重新竞争
Thread.yield();

4.3 线程加入

Thread thread = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("子线程: " + i);
    }
});

thread.start();
thread.join();  // 等待 thread 执行完毕
System.out.println("主线程继续");

// 带超时的 join
thread.join(1000);  // 最多等待 1 秒

4.4 线程中断

Thread thread = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            System.out.println("工作中...");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // sleep 被中断会抛出异常并清除中断标志
            System.out.println("收到中断信号");
            Thread.currentThread().interrupt();  // 重新设置中断标志
            break;
        }
    }
    System.out.println("线程结束");
});

thread.start();
Thread.sleep(3000);
thread.interrupt();  // 发送中断信号

4.5 线程优先级

Thread thread = new Thread(() -> {
    // 线程逻辑
});

// 设置优先级（1-10，默认 5）
thread.setPriority(Thread.MAX_PRIORITY);  // 10
thread.setPriority(Thread.MIN_PRIORITY);  // 1
thread.setPriority(Thread.NORM_PRIORITY); // 5

// 获取优先级
int priority = thread.getPriority();

4.6 守护线程

Thread daemon = new Thread(() -> {
    while (true) {
        System.out.println("守护线程运行中...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            break;
        }
    }
});

daemon.setDaemon(true);  // 设置为守护线程（必须在 start 之前）
daemon.start();

// 主线程结束后，守护线程自动结束
Thread.sleep(3000);
System.out.println("主线程结束");

---

5. 线程同步

5.1 线程安全问题

// 不安全的计数器
public class UnsafeCounter {
    private int count = 0;
    
    public void increment() {
        count++;  // 非原子操作：读取、加1、写入
    }
    
    public int getCount() {
        return count;
    }
}

// 测试
UnsafeCounter counter = new UnsafeCounter();
for (int i = 0; i < 1000; i++) {
    new Thread(() -> {
        for (int j = 0; j < 1000; j++) {
            counter.increment();
        }
    }).start();
}
// 结果可能小于 1000000

5.2 synchronized 关键字

// 同步方法
public class SafeCounter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

// 同步代码块
public class SafeCounter2 {
    private int count = 0;
    private final Object lock = new Object();
    
    public void increment() {
        synchronized (lock) {
            count++;
        }
    }
}

// 同步静态方法（锁定类对象）
public class SafeCounter3 {
    private static int count = 0;
    
    public static synchronized void increment() {
        count++;
    }
}

5.3 synchronized 原理

// synchronized 的实现基于 Monitor（监视器）
// 每个对象都有一个 Monitor

// 同步代码块编译后：
// monitorenter  // 获取锁
// ...           // 同步代码
// monitorexit   // 释放锁

// 锁的特性：
// 1. 可重入性：同一线程可以多次获取同一把锁
// 2. 非公平性：不保证等待时间最长的线程先获取锁

5.4 volatile 关键字

public class VolatileExample {
    private volatile boolean running = true;
    
    public void stop() {
        running = false;  // 对其他线程立即可见
    }
    
    public void run() {
        while (running) {
            // 工作
        }
    }
}

// volatile 的作用：
// 1. 保证可见性：一个线程修改后，其他线程立即可见
// 2. 禁止指令重排序
// 3. 不保证原子性

5.5 双重检查锁定

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {                    // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) {            // 第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

---

6. 线程通信

6.1 wait/notify/notifyAll

public class WaitNotifyExample {
    private final Object lock = new Object();
    private boolean ready = false;
    
    public void waitForReady() throws InterruptedException {
        synchronized (lock) {
            while (!ready) {
                lock.wait();  // 释放锁并等待
            }
            System.out.println("收到通知，继续执行");
        }
    }
    
    public void setReady() {
        synchronized (lock) {
            ready = true;
            lock.notifyAll();  // 通知所有等待的线程
        }
    }
}

6.2 生产者-消费者模式

public class ProducerConsumer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int capacity = 10;
    
    public void produce(int value) throws InterruptedException {
        synchronized (queue) {
            while (queue.size() == capacity) {
                queue.wait();  // 队列满，等待
            }
            queue.offer(value);
            System.out.println("生产: " + value);
            queue.notifyAll();
        }
    }
    
    public int consume() throws InterruptedException {
        synchronized (queue) {
            while (queue.isEmpty()) {
                queue.wait();  // 队列空，等待
            }
            int value = queue.poll();
            System.out.println("消费: " + value);
            queue.notifyAll();
            return value;
        }
    }
}

6.3 使用 Condition

public class ConditionExample {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final Queue<Integer> queue = new LinkedList<>();
    private final int capacity = 10;
    
    public void produce(int value) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                notFull.await();
            }
            queue.offer(value);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }
    
    public int consume() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            int value = queue.poll();
            notFull.signal();
            return value;
        } finally {
            lock.unlock();
        }
    }
}

---

7. 锁机制

7.1 ReentrantLock

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();  // 必须在 finally 中释放锁
        }
    }
    
    // 尝试获取锁
    public boolean tryIncrement() {
        if (lock.tryLock()) {
            try {
                count++;
                return true;
            } finally {
                lock.unlock();
            }
        }
        return false;
    }
    
    // 带超时的尝试获取锁
    public boolean tryIncrementWithTimeout() throws InterruptedException {
        if (lock.tryLock(1, TimeUnit.SECONDS)) {
            try {
                count++;
                return true;
            } finally {
                lock.unlock();
            }
        }
        return false;
    }
    
    // 可中断的获取锁
    public void interruptibleIncrement() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

7.2 公平锁与非公平锁

// 非公平锁（默认）
ReentrantLock unfairLock = new ReentrantLock();
ReentrantLock unfairLock2 = new ReentrantLock(false);

// 公平锁
ReentrantLock fairLock = new ReentrantLock(true);

// 公平锁保证等待时间最长的线程先获取锁
// 但性能比非公平锁低

7.3 ReadWriteLock

public class ReadWriteLockExample {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final Lock readLock = rwLock.readLock();
    private final Lock writeLock = rwLock.writeLock();
    private Map<String, String> cache = new HashMap<>();
    
    // 读操作（可多个线程同时读）
    public String get(String key) {
        readLock.lock();
        try {
            return cache.get(key);
        } finally {
            readLock.unlock();
        }
    }
    
    // 写操作（独占）
    public void put(String key, String value) {
        writeLock.lock();
        try {
            cache.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }
}

7.4 StampedLock（Java 8+）

public class StampedLockExample {
    private final StampedLock lock = new StampedLock();
    private double x, y;
    
    // 写锁
    public void move(double deltaX, double deltaY) {
        long stamp = lock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            lock.unlockWrite(stamp);
        }
    }
    
    // 乐观读
    public double distanceFromOrigin() {
        long stamp = lock.tryOptimisticRead();  // 乐观读，不阻塞
        double currentX = x, currentY = y;
        
        if (!lock.validate(stamp)) {  // 检查是否有写操作
            stamp = lock.readLock();  // 升级为悲观读锁
            try {
                currentX = x;
                currentY = y;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

7.5 死锁

// 死锁示例
public class DeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void method1() {
        synchronized (lock1) {
            System.out.println("持有 lock1，等待 lock2");
            synchronized (lock2) {
                System.out.println("持有 lock1 和 lock2");
            }
        }
    }
    
    public void method2() {
        synchronized (lock2) {
            System.out.println("持有 lock2，等待 lock1");
            synchronized (lock1) {
                System.out.println("持有 lock2 和 lock1");
            }
        }
    }
}

// 避免死锁的方法：
// 1. 按固定顺序获取锁
// 2. 使用 tryLock 带超时
// 3. 使用死锁检测

---

8. 线程池

8.1 线程池概述

线程池的优势：
1. 降低资源消耗：复用线程，减少创建销毁开销
2. 提高响应速度：任务到达时无需等待线程创建
3. 提高可管理性：统一管理、调优和监控

8.2 ThreadPoolExecutor

// 核心构造方法
public ThreadPoolExecutor(
    int corePoolSize,           // 核心线程数
    int maximumPoolSize,        // 最大线程数
    long keepAliveTime,         // 空闲线程存活时间
    TimeUnit unit,              // 时间单位
    BlockingQueue<Runnable> workQueue,  // 工作队列
    ThreadFactory threadFactory,        // 线程工厂
    RejectedExecutionHandler handler    // 拒绝策略
)

// 创建线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5,                                  // 核心线程数
    10,                                 // 最大线程数
    60L, TimeUnit.SECONDS,              // 空闲线程存活时间
    new LinkedBlockingQueue<>(100),     // 工作队列
    Executors.defaultThreadFactory(),   // 线程工厂
    new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
);

8.3 工作队列

// 有界队列
new ArrayBlockingQueue<>(100);
new LinkedBlockingQueue<>(100);

// 无界队列（慎用，可能导致 OOM）
new LinkedBlockingQueue<>();

// 同步移交队列（不存储任务）
new SynchronousQueue<>();

// 优先级队列
new PriorityBlockingQueue<>();

8.4 拒绝策略

// AbortPolicy（默认）：抛出 RejectedExecutionException
new ThreadPoolExecutor.AbortPolicy();

// CallerRunsPolicy：由调用线程执行任务
new ThreadPoolExecutor.CallerRunsPolicy();

// DiscardPolicy：静默丢弃任务
new ThreadPoolExecutor.DiscardPolicy();

// DiscardOldestPolicy：丢弃队列中最老的任务
new ThreadPoolExecutor.DiscardOldestPolicy();

// 自定义拒绝策略
RejectedExecutionHandler customHandler = (r, executor) -> {
    // 记录日志、持久化任务等
    System.out.println("任务被拒绝: " + r.toString());
};

8.5 Executors 工厂方法

// 固定大小线程池
ExecutorService fixed = Executors.newFixedThreadPool(10);

// 缓存线程池（线程数无上限）
ExecutorService cached = Executors.newCachedThreadPool();

// 单线程池
ExecutorService single = Executors.newSingleThreadExecutor();

// 调度线程池
ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(5);

// 工作窃取线程池（Java 8+）
ExecutorService workStealing = Executors.newWorkStealingPool();

// 注意：阿里巴巴规范建议使用 ThreadPoolExecutor 而非 Executors

8.6 线程池使用

ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交 Runnable
executor.execute(() -> {
    System.out.println("执行任务");
});

// 提交 Callable
Future<String> future = executor.submit(() -> {
    return "任务结果";
});
String result = future.get();

// 批量提交
List<Callable<Integer>> tasks = Arrays.asList(
    () -> 1,
    () -> 2,
    () -> 3
);
List<Future<Integer>> futures = executor.invokeAll(tasks);

// 任意一个完成即返回
Integer first = executor.invokeAny(tasks);

// 关闭线程池
executor.shutdown();  // 平滑关闭，等待任务完成
executor.shutdownNow();  // 立即关闭，中断正在执行的任务
executor.awaitTermination(60, TimeUnit.SECONDS);  // 等待关闭完成

8.7 ScheduledExecutorService

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);

// 延迟执行
scheduler.schedule(() -> {
    System.out.println("延迟 3 秒执行");
}, 3, TimeUnit.SECONDS);

// 固定频率执行
scheduler.scheduleAtFixedRate(() -> {
    System.out.println("每 2 秒执行一次");
}, 0, 2, TimeUnit.SECONDS);

// 固定延迟执行
scheduler.scheduleWithFixedDelay(() -> {
    System.out.println("上次执行完成后延迟 2 秒执行");
}, 0, 2, TimeUnit.SECONDS);

---

9. 并发工具类

9.1 CountDownLatch

// 等待多个线程完成
CountDownLatch latch = new CountDownLatch(3);

for (int i = 0; i < 3; i++) {
    final int index = i;
    new Thread(() -> {
        System.out.println("任务 " + index + " 完成");
        latch.countDown();  // 计数减 1
    }).start();
}

latch.await();  // 等待计数归零
System.out.println("所有任务完成");

// 带超时的等待
boolean completed = latch.await(10, TimeUnit.SECONDS);

9.2 CyclicBarrier

// 多个线程互相等待
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有线程到达屏障");
});

for (int i = 0; i < 3; i++) {
    final int index = i;
    new Thread(() -> {
        System.out.println("线程 " + index + " 到达屏障");
        try {
            barrier.await();  // 等待其他线程
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("线程 " + index + " 继续执行");
    }).start();
}

// CyclicBarrier 可以重复使用
barrier.reset();

9.3 Semaphore

// 信号量，控制并发访问数量
Semaphore semaphore = new Semaphore(3);  // 最多 3 个线程同时访问

for (int i = 0; i < 10; i++) {
    final int index = i;
    new Thread(() -> {
        try {
            semaphore.acquire();  // 获取许可
            System.out.println("线程 " + index + " 获取许可");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();  // 释放许可
            System.out.println("线程 " + index + " 释放许可");
        }
    }).start();
}

// 尝试获取许可
boolean acquired = semaphore.tryAcquire();
boolean acquiredWithTimeout = semaphore.tryAcquire(1, TimeUnit.SECONDS);

9.4 Exchanger

// 两个线程交换数据
Exchanger<String> exchanger = new Exchanger<>();

new Thread(() -> {
    try {
        String data = "来自线程 A 的数据";
        String received = exchanger.exchange(data);
        System.out.println("线程 A 收到: " + received);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

new Thread(() -> {
    try {
        String data = "来自线程 B 的数据";
        String received = exchanger.exchange(data);
        System.out.println("线程 B 收到: " + received);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

9.5 Phaser

// 分阶段执行
Phaser phaser = new Phaser(3);  // 3 个参与者

for (int i = 0; i < 3; i++) {
    final int index = i;
    new Thread(() -> {
        System.out.println("线程 " + index + " 完成阶段 1");
        phaser.arriveAndAwaitAdvance();  // 等待所有线程完成阶段 1
        
        System.out.println("线程 " + index + " 完成阶段 2");
        phaser.arriveAndAwaitAdvance();  // 等待所有线程完成阶段 2
        
        System.out.println("线程 " + index + " 完成阶段 3");
        phaser.arriveAndDeregister();    // 完成并注销
    }).start();
}

---

10. 原子类

10.1 基本原子类

// AtomicInteger
AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.get();                    // 获取值
atomicInt.set(10);                  // 设置值
atomicInt.getAndSet(20);            // 获取并设置
atomicInt.incrementAndGet();        // 自增并获取
atomicInt.getAndIncrement();        // 获取并自增
atomicInt.addAndGet(5);             // 加并获取
atomicInt.compareAndSet(25, 30);    // CAS 操作
atomicInt.updateAndGet(x -> x * 2); // 更新并获取

// AtomicLong
AtomicLong atomicLong = new AtomicLong(0L);

// AtomicBoolean
AtomicBoolean atomicBoolean = new AtomicBoolean(false);

10.2 原子引用

// AtomicReference
AtomicReference<String> atomicRef = new AtomicReference<>("Hello");
atomicRef.compareAndSet("Hello", "World");

// AtomicStampedReference（解决 ABA 问题）
AtomicStampedReference<String> stampedRef = 
    new AtomicStampedReference<>("Hello", 0);
int[] stampHolder = new int[1];
String value = stampedRef.get(stampHolder);
stampedRef.compareAndSet("Hello", "World", stampHolder[0], stampHolder[0] + 1);

// AtomicMarkableReference
AtomicMarkableReference<String> markableRef = 
    new AtomicMarkableReference<>("Hello", false);

10.3 原子数组

// AtomicIntegerArray
AtomicIntegerArray atomicArray = new AtomicIntegerArray(10);
atomicArray.get(0);
atomicArray.set(0, 100);
atomicArray.incrementAndGet(0);
atomicArray.compareAndSet(0, 101, 200);

// AtomicLongArray
AtomicLongArray atomicLongArray = new AtomicLongArray(10);

// AtomicReferenceArray
AtomicReferenceArray<String> atomicRefArray = new AtomicReferenceArray<>(10);

10.4 字段更新器

public class FieldUpdaterExample {
    private volatile int count;
    
    private static final AtomicIntegerFieldUpdater<FieldUpdaterExample> updater =
        AtomicIntegerFieldUpdater.newUpdater(FieldUpdaterExample.class, "count");
    
    public void increment() {
        updater.incrementAndGet(this);
    }
}

10.5 LongAdder 和 LongAccumulator

// LongAdder（高并发下比 AtomicLong 性能更好）
LongAdder adder = new LongAdder();
adder.increment();
adder.add(10);
long sum = adder.sum();

// LongAccumulator
LongAccumulator accumulator = new LongAccumulator(Long::max, 0);
accumulator.accumulate(10);
accumulator.accumulate(5);
long result = accumulator.get();  // 10

---

11. 并发集合

11.1 ConcurrentHashMap

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// 基本操作
map.put("key", 1);
map.get("key");
map.remove("key");

// 原子操作
map.putIfAbsent("key", 1);
map.computeIfAbsent("key", k -> 1);
map.computeIfPresent("key", (k, v) -> v + 1);
map.compute("key", (k, v) -> v == null ? 1 : v + 1);
map.merge("key", 1, Integer::sum);

// 批量操作
map.forEach((k, v) -> System.out.println(k + ": " + v));
map.search(1, (k, v) -> v > 10 ? k : null);
map.reduce(1, (k, v) -> v, Integer::sum);

11.2 CopyOnWriteArrayList

// 适用于读多写少的场景
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

list.add("item1");
list.add("item2");

// 迭代时可以修改（不会抛出 ConcurrentModificationException）
for (String item : list) {
    if (item.equals("item1")) {
        list.remove(item);  // 安全
    }
}

11.3 ConcurrentLinkedQueue

ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

queue.offer("item1");
queue.offer("item2");
String item = queue.poll();
String peek = queue.peek();

11.4 BlockingQueue

// ArrayBlockingQueue（有界）
BlockingQueue<String> arrayQueue = new ArrayBlockingQueue<>(100);

// LinkedBlockingQueue（可选有界）
BlockingQueue<String> linkedQueue = new LinkedBlockingQueue<>(100);

// PriorityBlockingQueue（优先级）
BlockingQueue<String> priorityQueue = new PriorityBlockingQueue<>();

// 阻塞操作
arrayQueue.put("item");      // 队列满时阻塞
String item = arrayQueue.take();  // 队列空时阻塞

// 超时操作
arrayQueue.offer("item", 1, TimeUnit.SECONDS);
String item2 = arrayQueue.poll(1, TimeUnit.SECONDS);

11.5 ConcurrentSkipListMap/Set

// 并发有序 Map
ConcurrentSkipListMap<String, Integer> skipListMap = new ConcurrentSkipListMap<>();
skipListMap.put("b", 2);
skipListMap.put("a", 1);
skipListMap.put("c", 3);
// 遍历时有序

// 并发有序 Set
ConcurrentSkipListSet<String> skipListSet = new ConcurrentSkipListSet<>();

---

12. CompletableFuture

12.1 创建 CompletableFuture

// 创建已完成的 Future
CompletableFuture<String> completed = CompletableFuture.completedFuture("result");

// 异步执行（无返回值）
CompletableFuture<Void> runAsync = CompletableFuture.runAsync(() -> {
    System.out.println("异步执行");
});

// 异步执行（有返回值）
CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> {
    return "异步结果";
});

// 使用自定义线程池
ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> customAsync = CompletableFuture.supplyAsync(() -> {
    return "自定义线程池";
}, executor);

12.2 结果处理

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");

// thenApply：转换结果
CompletableFuture<Integer> lengthFuture = future.thenApply(String::length);

// thenAccept：消费结果
future.thenAccept(System.out::println);

// thenRun：执行后续操作（不使用结果）
future.thenRun(() -> System.out.println("完成"));

// 异步版本
future.thenApplyAsync(String::length);
future.thenAcceptAsync(System.out::println);
future.thenRunAsync(() -> System.out.println("完成"));

12.3 组合操作

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

// thenCompose：扁平化组合
CompletableFuture<String> composed = future1.thenCompose(s -> 
    CompletableFuture.supplyAsync(() -> s + " World"));

// thenCombine：合并两个结果
CompletableFuture<String> combined = future1.thenCombine(future2, 
    (s1, s2) -> s1 + " " + s2);

// allOf：等待所有完成
CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2);

// anyOf：任意一个完成
CompletableFuture<Object> anyOf = CompletableFuture.anyOf(future1, future2);

12.4 异常处理

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("错误");
    return "result";
});

// exceptionally：处理异常
CompletableFuture<String> handled = future.exceptionally(ex -> {
    System.out.println("异常: " + ex.getMessage());
    return "默认值";
});

// handle：处理结果或异常
CompletableFuture<String> handleFuture = future.handle((result, ex) -> {
    if (ex != null) {
        return "异常: " + ex.getMessage();
    }
    return result;
});

// whenComplete：完成时回调（不改变结果）
future.whenComplete((result, ex) -> {
    if (ex != null) {
        System.out.println("异常: " + ex.getMessage());
    } else {
        System.out.println("结果: " + result);
    }
});

12.5 获取结果

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "result");

// 阻塞获取
String result = future.get();

// 带超时获取
String result2 = future.get(1, TimeUnit.SECONDS);

// 立即获取（未完成返回默认值）
String result3 = future.getNow("default");

// join（不抛出受检异常）
String result4 = future.join();

---

13. 实战案例

13.1 线程安全的单例模式

// 双重检查锁定
public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// 静态内部类
public class Singleton2 {
    private Singleton2() {}
    
    private static class Holder {
        private static final Singleton2 INSTANCE = new Singleton2();
    }
    
    public static Singleton2 getInstance() {
        return Holder.INSTANCE;
    }
}

// 枚举（推荐）
public enum Singleton3 {
    INSTANCE;
    
    public void doSomething() {
        // ...
    }
}

13.2 线程池最佳实践

public class ThreadPoolManager {
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    
    // CPU 密集型任务
    public static ExecutorService createCpuIntensivePool() {
        return new ThreadPoolExecutor(
            CPU_COUNT + 1,
            CPU_COUNT + 1,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(100),
            new ThreadFactoryBuilder().setNameFormat("cpu-pool-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
    
    // IO 密集型任务
    public static ExecutorService createIoIntensivePool() {
        return new ThreadPoolExecutor(
            CPU_COUNT * 2,
            CPU_COUNT * 2,
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(200),
            new ThreadFactoryBuilder().setNameFormat("io-pool-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
}

13.3 并发任务处理

public class ConcurrentTaskProcessor {
    private final ExecutorService executor;
    
    public ConcurrentTaskProcessor(int threads) {
        this.executor = Executors.newFixedThreadPool(threads);
    }
    
    // 并行处理列表
    public <T, R> List<R> processInParallel(List<T> items, Function<T, R> processor) {
        List<CompletableFuture<R>> futures = items.stream()
            .map(item -> CompletableFuture.supplyAsync(() -> processor.apply(item), executor))
            .collect(Collectors.toList());
        
        return futures.stream()
            .map(CompletableFuture::join)
            .collect(Collectors.toList());
    }
    
    // 带超时的并行处理
    public <T, R> List<R> processWithTimeout(List<T> items, Function<T, R> processor, 
            long timeout, TimeUnit unit) throws Exception {
        List<Callable<R>> tasks = items.stream()
            .map(item -> (Callable<R>) () -> processor.apply(item))
            .collect(Collectors.toList());
        
        List<Future<R>> futures = executor.invokeAll(tasks, timeout, unit);
        
        return futures.stream()
            .map(f -> {
                try {
                    return f.get();
                } catch (Exception e) {
                    return null;
                }
            })
            .collect(Collectors.toList());
    }
    
    public void shutdown() {
        executor.shutdown();
    }
}

13.4 限流器

public class RateLimiter {
    private final Semaphore semaphore;
    private final int permitsPerSecond;
    private final ScheduledExecutorService scheduler;
    
    public RateLimiter(int permitsPerSecond) {
        this.permitsPerSecond = permitsPerSecond;
        this.semaphore = new Semaphore(permitsPerSecond);
        this.scheduler = Executors.newSingleThreadScheduledExecutor();
        
        // 每秒重置许可
        scheduler.scheduleAtFixedRate(() -> {
            int permitsToRelease = permitsPerSecond - semaphore.availablePermits();
            if (permitsToRelease > 0) {
                semaphore.release(permitsToRelease);
            }
        }, 1, 1, TimeUnit.SECONDS);
    }
    
    public boolean tryAcquire() {
        return semaphore.tryAcquire();
    }
    
    public void acquire() throws InterruptedException {
        semaphore.acquire();
    }
    
    public void shutdown() {
        scheduler.shutdown();
    }
}

---

14. 最佳实践

14.1 线程安全原则

// ✅ 使用不可变对象
public final class ImmutableUser {
    private final String name;
    private final int age;
    
    public ImmutableUser(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
}

// ✅ 使用线程安全的集合
Map<String, String> map = new ConcurrentHashMap<>();
List<String> list = new CopyOnWriteArrayList<>();

// ✅ 使用原子类
AtomicInteger counter = new AtomicInteger(0);

14.2 锁使用原则

// ✅ 缩小锁的范围
public void process() {
    // 不需要同步的代码
    prepareData();
    
    synchronized (lock) {
        // 只同步必要的代码
        updateSharedState();
    }
    
    // 不需要同步的代码
    cleanup();
}

// ✅ 使用 try-finally 确保释放锁
Lock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区代码
} finally {
    lock.unlock();
}

// ✅ 避免嵌套锁
// ❌ 容易死锁
synchronized (lock1) {
    synchronized (lock2) {
        // ...
    }
}

14.3 线程池使用原则

// ✅ 使用 ThreadPoolExecutor 而非 Executors
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,
    maxPoolSize,
    keepAliveTime, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(queueSize),
    threadFactory,
    rejectedHandler
);

// ✅ 为线程池命名
ThreadFactory namedFactory = new ThreadFactoryBuilder()
    .setNameFormat("my-pool-%d")
    .build();

// ✅ 正确关闭线程池
executor.shutdown();
try {
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow();
    }
} catch (InterruptedException e) {
    executor.shutdownNow();
    Thread.currentThread().interrupt();
}

14.4 避免常见问题

// ❌ 不要在循环中创建线程
for (int i = 0; i < 1000; i++) {
    new Thread(() -> { /* ... */ }).start();  // 错误
}

// ✅ 使用线程池
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 1000; i++) {
    executor.execute(() -> { /* ... */ });
}

// ❌ 不要忽略 InterruptedException
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // 不要忽略
}

// ✅ 正确处理中断
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();  // 重新设置中断标志
    // 或者抛出异常
}

---

附录：多线程速查表

线程状态

状态	说明
NEW	新建，未启动
RUNNABLE	可运行，正在运行或等待 CPU
BLOCKED	阻塞，等待获取锁
WAITING	等待，无限期等待
TIMED_WAITING	超时等待，有时限等待
TERMINATED	终止，执行完毕

常用并发工具

工具	用途
CountDownLatch	等待多个线程完成
CyclicBarrier	多个线程互相等待
Semaphore	控制并发访问数量
Exchanger	两个线程交换数据
Phaser	分阶段执行

线程池参数

参数	说明
corePoolSize	核心线程数
maximumPoolSize	最大线程数
keepAliveTime	空闲线程存活时间
workQueue	工作队列
threadFactory	线程工厂
handler	拒绝策略