在现代软件架构中,并发编程已成为提升系统吞吐量与响应能力的核心能力之一。尤其在高并发服务、分布式系统、实时计算等场景下,掌握Java多线程详细知识不仅是开发工程师的基本功,更是构建高性能、高可用系统的基石。本文将系统性梳理Java并发编程体系,从基础概念到高级机制,结合真实项目经验与高频面试考点,帮助您构建完整的知识图谱。
随着多核CPU的普及与微架构演进(如Intel的SMT技术),单线程模型已无法充分发挥硬件潜力。Java作为主流企业级语言,其并发工具包提供了从底层线程控制到高层抽象API的全栈支持。理解这些机制,有助于避免常见陷阱(如死锁、活锁、饥饿),提升代码健壮性与可维护性。
需要特别注意的是,线程安全并非仅靠`synchronized`关键字就能保证。它涉及原子性、可见性、有序性三个维度的协调统一。例如,`volatile`关键字仅能保证可见性与有序性,却无法保证复合操作的原子性;而`AtomicInteger`通过CAS机制实现无锁线程安全,其性能通常优于`synchronized`,但需警惕ABA问题与自旋开销。
本文内容覆盖:线程生命周期、线程创建与启动、线程同步机制(synchronized、Lock、volatile)、线程通信(wait/notify、Condition)、线程池设计(ThreadPoolExecutor参数详解)、JUC核心组件(CountDownLatch、CyclicBarrier、Semaphore)、内存模型(happens-before规则、JMM抽象结构)、实战案例(生产者-消费者、读写缓存、限流熔断)等八大模块。每个主题均附有可运行代码示例与性能对比分析,确保知识可落地、可验证。
Java线程模型基于操作系统原生线程实现,遵循“1:1”映射模型(JVM线程 ↔ OS线程)。创建线程主要有三种方式:继承`Thread`类、实现`Runnable`接口、实现`Callable`接口。其中,`Runnable`与`Callable`更推荐使用,因其避免了单继承局限,且支持返回值与异常处理。
线程生命周期包含5种状态:NEW(创建后未启动)、RUNNABLE(就绪/运行中)、BLOCKED(等待监视器锁)、WAITING(无限期等待)、TIMED_WAITING(限时等待)。理解状态转换对排查线程问题至关重要。例如,当线程卡在`BLOCKED`状态时,通常表明存在锁竞争或死锁。
线程优先级范围为1~10(Thread.MIN_PRIORITY ~ Thread.MAX_PRIORITY),默认为5(Thread.NORM_PRIORITY)。但需注意:线程优先级不具备可移植性,其行为依赖于操作系统调度器实现。例如在Linux中,Java线程优先级会被映射到NICE值,而不同发行版可能采用不同策略。
Thread t = new Thread(() -> {
System.out.println("当前状态:" + Thread.currentThread().getState());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println("启动前:" + t.getState()); // NEW
t.start();
System.out.println("启动后:" + t.getState()); // RUNNABLE/BLOCKED/WAITING等
线程中断机制是协作式而非强制式。通过`interrupt()`方法设置中断标志位,线程需主动检查并处理中断(如抛出`InterruptedException`或检查`isInterrupted()`)。常见误区是忽略中断信号导致线程无法正常退出,尤其在循环中应定期检查中断状态。
线程同步的核心目标是保证原子性(操作不可分割)、可见性(修改对其他线程可见)、有序性(指令不被重排序)。Java通过`synchronized`、`volatile`、`Lock`等机制协同实现这些语义。
`synchronized`可修饰方法或代码块,底层通过监视器锁(Monitor)实现。对象头中包含锁标志位,JVM会根据竞争程度动态调整锁策略(偏向锁→轻量级锁→重量级锁)。
public class SafeCounter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
需警惕锁竞争升级:当多个线程频繁竞争同一锁时,JVM会将偏向锁升级为重量级锁,导致上下文切换开销剧增。可通过`-XX:+UseBiasedLocking`(JDK 8默认开启,JDK 15起默认关闭)调整策略。
`volatile`确保变量修改对所有线程立即可见,并禁止指令重排序。适用于状态标记(如`volatile boolean running = true;`)与单例双重检查锁定(DCL)场景。
public class Singleton {
private static volatile Singleton instance;
public static Singleton getInstance() {
if (instance == null) { // 第一次检查
synchronized (Singleton.class) {
if (instance == null) { // 第二次检查
instance = new Singleton();
}
}
}
return instance;
}
}
注意:`volatile`无法保证复合操作的原子性。例如`volatile int count = 0; count++;`仍需额外同步机制,因为`++`包含读-改-写三步操作。
`Lock`提供比`synchronized`更灵活的锁操作,支持尝试获取锁(`tryLock()`)、可中断获取锁(`lockInterruptibly()`)、公平锁等高级特性。核心实现类包括`ReentrantLock`(可重入锁)、`ReentrantReadWriteLock`(读写锁)。
public class ThreadSafeQueue{ private final List list = new ArrayList<>(); private final Lock lock = new ReentrantLock(); public void add(T item) { lock.lock(); try { list.add(item); } finally { lock.unlock(); } } public T remove() { lock.lock(); try { return list.isEmpty() ? null : list.remove(0); } finally { lock.unlock(); } } }
读写锁适用于读多写少场景。`ReentrantReadWriteLock`允许多个读线程并发访问,但写线程独占访问。需注意:锁降级(写锁→读锁)是安全的,但锁升级(读锁→写锁)会导致死锁。
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putptr] = x;
putptr = (putptr + 1) % items.length;
++count;
notEmpty.signal(); // 仅唤醒消费者
} finally {
lock.unlock();
}
}
}
线程池通过复用线程避免频繁创建/销毁开销,是高并发系统的必备组件。`ThreadPoolExecutor`是核心实现类,其构造参数直接影响线程池行为:
| 参数 | 作用 | 典型值 |
|---|---|---|
| corePoolSize | 核心线程数 | CPU核心数 + 1(IO密集型可更高) |
| maximumPoolSize | 最大线程数 | 根据任务特性动态调整 |
| keepAliveTime | 非核心线程存活时间 | 60秒(空闲时释放) |
| workQueue | 任务队列 | LinkedBlockingQueue、ArrayBlockingQueue等 |
| threadFactory | 线程工厂 | 自定义命名(便于问题排查) |
| handler | 拒绝策略 | AbortPolicy、CallerRunsPolicy等 |
队列类型选择直接影响系统行为:
int cpuCount = Runtime.getRuntime().availableProcessors();
int corePoolSize = cpuCount + 1;
int maxPoolSize = cpuCount * 2;
ExecutorService pool = new ThreadPoolExecutor(
corePoolSize,
maxPoolSize,
60L, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(1000),
new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
拒绝策略选择需结合业务场景:
`java.util.concurrent`(JUC)包提供了丰富的并发工具,大幅简化并发编程难度。核心组件包括同步器(Synchronizers)、并发集合(Collections)与原子变量(Atomic)。
允许一个或多个线程等待其他线程完成操作。适用于主线程等待多个子任务完成后再继续执行的场景。
CountDownLatch latch = new CountDownLatch(3);
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
pool.submit(() -> {
try {
// 模拟初始化操作
Thread.sleep(1000);
System.out.println("子任务完成");
} finally {
latch.countDown();
}
});
}
latch.await(); // 等待所有子任务完成
System.out.println("所有初始化完成,继续执行...");
pool.shutdown();
允许一组线程互相等待,直到所有线程到达屏障点。可重用,适用于分阶段计算(如MapReduce)。
int[] data = {1,2,3,4,5,6,7,8};
int partSize = data.length / 2;
CyclicBarrier barrier = new CyclicBarrier(2, () -> {
System.out.println("所有部分计算完成,合并结果");
});
for (int i = 0; i < 2; i++) {
final int start = i * partSize;
final int end = (i == 1) ? data.length : start + partSize;
new Thread(() -> {
int sum = 0;
for (int j = start; j < end; j++) {
sum += data[j];
}
System.out.println("部分和:" + sum);
try {
barrier.await(); // 等待其他线程
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
控制同时访问特定资源的线程数量,适用于限流场景(如数据库连接池)。
Semaphore semaphore = new Semaphore(5); // 最多5个连接
ExecutorService pool = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
pool.submit(() -> {
try {
semaphore.acquire();
// 获取连接并执行查询
System.out.println(Thread.currentThread().getName() + " 获取连接");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
System.out.println(Thread.currentThread().getName() + " 释放连接");
}
});
}
原子变量通过CAS(Compare-And-Swap)实现无锁线程安全,避免了`synchronized`的上下文切换开销。核心类包括`AtomicInteger`、`AtomicReference`、`AtomicLong`等。
CAS原理:比较内存值与期望值,若相等则更新为新值,否则重试。需注意:
AtomicStampedReferenceref = new AtomicStampedReference<>(100, 1); // 线程1:修改值并更新时间戳 int[] stamp = {0}; int val = ref.get(stamp); ref.compareAndSet(val, 200, stamp[0], stamp[0] + 1); // 线程2:尝试修改(时间戳不匹配) boolean success = ref.compareAndSet(100, 300, 1, 2); // 失败!
| 集合类型 | 线程安全实现 | 适用场景 |
|---|---|---|
| List | `CopyOnWriteArrayList` | 读多写少(如监听器列表) |
| Set | `ConcurrentSkipListSet` | 需要排序且高并发(如在线用户ID集合) |
| Map | `ConcurrentHashMap` | 高并发读写(如缓存、会话管理) |
| Queue | `ConcurrentLinkedQueue` | 无界队列(如异步任务分发) |
`ConcurrentHashMap`采用分段锁(JDK 8起为CAS + synchronized)实现高并发,其核心优化包括:
// HashMap + Collections.synchronizedMap:性能差,全表锁 Mapmap1 = Collections.synchronizedMap(new HashMap<>()); // ConcurrentHashMap:高性能,分段锁 Map map2 = new ConcurrentHashMap<>(); map2.put("key", "value"); // CopyOnWriteArrayList:写时复制,适合读多写少 List list = new CopyOnWriteArrayList<>(); list.add("item");
Java内存模型(JMM)定义了线程与主内存之间的抽象关系,核心目标是保证并发程序的正确性。其三大特性:原子性(通过synchronized保证)、可见性(通过volatile、synchronized保证)、有序性(通过happens-before规则保证)。
程序执行顺序不等于代码顺序,JMM通过happens-before定义操作间的可见性约束:
class FlagExample {
private volatile boolean flag = false;
private int data = 0;
public void writer() {
data = 42; // 1. 写普通变量
flag = true; // 2. 写volatile变量
}
public void reader() {
if (flag) { // 3. 读volatile变量
System.out.println(data); // 4. 必须读到42!
}
}
}
需注意:`volatile`禁止的是指令重排序,但仅保证对volatile变量的读写顺序。例如`a = 1; b = 2;`中,若b是volatile,则a=1一定在b=2之前执行,但其他线程可能先看到b=2而未看到a=1(除非通过其他机制保证)。
理论知识需结合实践验证。以下通过三个典型场景,展示如何应用并发知识解决实际问题。
使用`BlockingQueue`简化生产者-消费者同步逻辑,避免手动管理wait/notify。
public class ProducerConsumerDemo {
private static final int QUEUE_SIZE = 10;
private static final BlockingQueue queue = new ArrayBlockingQueue<>(QUEUE_SIZE);
public static void main(String[] args) {
// 生产者线程
new Thread(() -> {
try {
for (int i = 0; i < 20; i++) {
queue.put(i);
System.out.println("生产:" + i);
Thread.sleep(100);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
// 消费者线程
new Thread(() -> {
try {
while (true) {
Integer value = queue.take();
System.out.println("消费:" + value);
Thread.sleep(200);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
优势:解耦生产与消费速率,队列满时自动阻塞生产者,队列空时自动阻塞消费者,无需手动同步。
适用于读多写少的缓存场景,提升并发吞吐量。
public class Cache{ private final Map cache = new HashMap<>(); private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); private final Lock readLock = lock.readLock(); private final Lock writeLock = lock.writeLock(); public V get(K key) { readLock.lock(); try { return cache.get(key); } finally { readLock.unlock(); } } public void put(K key, V value) { writeLock.lock(); try { cache.put(key, value); } finally { writeLock.unlock(); } } }
性能对比:在1000次读操作+10次写操作中,`ReentrantReadWriteLock`比`synchronized`快3倍以上。
结合`Semaphore`与`ThreadPoolExecutor`实现服务降级,防止雪崩。
public class RateLimiterService {
private final Semaphore semaphore = new Semaphore(50); // 50并发
private final ExecutorService executor = new ThreadPoolExecutor(
20, 100, 60L, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(200)
);
public String callRemoteService(String param) throws Exception {
if (!semaphore.tryAcquire(100, TimeUnit.MILLISECONDS)) {
throw new RuntimeException("服务过载,触发限流");
}
try {
Future future = executor.submit(() -> {
// 模拟远程调用
Thread.sleep(50);
return "result:" + param;
});
return future.get(200, TimeUnit.MILLISECONDS); // 200ms超时
} finally {
semaphore.release();
}
}
}
效果:当服务过载时,主动拒绝新请求,保护下游服务,同时通过超时机制避免线程长期阻塞。
| 指标 | 优化方向 | 监控工具 |
|---|---|---|
| 线程上下文切换 | 减少线程数、使用无锁算法 | `vmstat`、`perf` |
| 锁竞争 | 减小锁粒度、使用CAS替代synchronized | `jstack`、`jvisualvm` |
| 内存占用 | 合理设置线程栈大小(-Xss) | `jmap`、`MAT` |
| 吞吐量 | 优化队列长度、调整核心线程数 | `JMH`基准测试 |
A:`volatile`仅保证单次读/写操作的原子性,而`count++`包含三步(读→改→写),中间可能被其他线程插入。例如:线程A读count=5,线程B也读count=5,两者都加1后写回6,导致丢失更新。解决方案:使用`AtomicInteger`或`synchronized`。
A:通过`jstack`命令查看线程堆栈,若存在`BLOCKED`状态且循环等待资源,则可能死锁。生产环境可集成`ThreadMXBean`实时监控:
ThreadMXBean bean = ManagementFactory.getThreadMXBean();
long[] deadlockedThreads = bean.findDeadlockedThreads();
if (deadlockedThreads != null) {
System.out.println("检测到死锁!");
for (long id : deadlockedThreads) {
System.out.println("线程ID:" + id);
}
}
A:需结合任务类型:
• CPU密集型:线程数 ≈ CPU核心数(如`Runtime.getRuntime().availableProcessors()`)
• IO密集型:线程数 ≈ CPU核心数 × (1 + IO耗时/计算耗时)(通常为2倍)
• 混合型:拆分为CPU/IO子任务,分别配置线程池
A:`Executors`工厂类存在严重隐患:
• `newFixedThreadPool`使用无界队列,任务堆积导致OOM
• `newCachedThreadPool`最大线程数为Integer.MAX_VALUE,高并发时创建过多线程导致系统崩溃
• 缺乏监控与调优能力
推荐直接使用`ThreadPoolExecutor`,显式指定队列容量与拒绝策略。
A:推荐三种方案:
1. 静态内部类(推荐):利用JVM类加载机制保证线程安全
2. 枚举:天然单例,防止反射攻击
3. DCL + volatile:需正确实现双重检查锁定
避免使用`synchronized`修饰整个`getInstance()`方法(性能差)。