在当今互联网高并发场景下,单线程模型早已无法满足海量用户请求的处理需求。从电商平台秒杀系统、即时通讯服务,到大数据计算框架与微服务架构,java多线程处理已成为后端开发工程师必须掌握的核心技能。本页面系统梳理从线程创建、同步控制到线程池优化的完整知识体系,结合真实业务场景与高频问题,帮助开发者构建扎实的并发编程能力。
线程作为操作系统调度的最小单位,具备独立的执行路径与栈空间,但共享进程的堆内存与文件资源。在Java中,线程通过java.lang.Thread类或java.lang.Runnable接口实现。一个进程可包含多个线程,它们并发执行以提升CPU利用率与系统吞吐量。然而,多线程并非简单叠加效率——若缺乏正确同步机制,极易引发数据竞争、死锁、活锁、线程饥饿等隐蔽性问题,造成系统不稳定甚至服务崩溃。
Java内存模型(JMM)为并发编程提供了抽象规范,定义了线程与主内存之间的交互语义。理解volatile关键字、happens-before规则、内存屏障等概念,是编写线程安全代码的前提。此外,JDK并发包(java.util.concurrent)提供了丰富的高层抽象工具,如Executor框架、CountDownLatch、CyclicBarrier、Semaphore、ConcurrentHashMap等,极大简化了并发编程的复杂度。
本文档面向具备Java基础的开发者,内容涵盖:线程创建与启动方式对比、线程状态转换图解、线程池参数调优策略、JMM内存可见性与有序性保障机制、各种锁(可重入锁、读写锁、StampedLock)的适用场景、并发容器底层实现原理、并发工具类的典型用法,以及高并发系统常见性能瓶颈与优化手段。所有示例均经过实际测试,确保可运行性与工程可行性。
特别提示:本文不涉及多线程调试技巧(如jstack分析、Arthas跟踪)与分布式线程协调(如ZooKeeper、Redisson分布式锁),相关内容将单独成篇。当前聚焦于单JVM内的并发模型与编程实践,适合用于日常开发参考与面试复习。
① 性能刚需:现代CPU普遍具备多核特性,单线程程序无法充分利用硬件资源。据测试,在相同I/O密集型任务中,合理使用4线程可使处理时间缩短约75%(受限于Amdahl定律)。
② 响应体验:Web服务器若采用阻塞式单线程处理请求,用户等待时间随并发量线性增长。而多线程异步处理可将平均响应时间稳定在毫秒级。
③ 架构演进:微服务、事件驱动、Reactor模式等现代架构均以线程模型为基础。Netty、Spring Reactor等框架内部大量使用线程池与非阻塞IO,脱离线程知识难以深入理解其设计思想。
④ 面试门槛:90%以上中高级Java岗位明确要求掌握并发编程,常见考点包括:线程池参数设计、volatile与synchronized区别、CAS原理、ABA问题解决方案、线程上下文切换开销估算等。
Java中创建线程主要有三种方式:继承Thread类、实现Runnable接口、实现Callable接口。每种方式适用场景不同,需根据业务需求选择。
直接继承Thread类并重写run()方法。该方式简单直观,但受限于Java单继承机制,一旦继承Thread,子类无法再继承其他类,灵活性较低。
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("线程执行中:" + Thread.currentThread().getName());
for (int i = 0; i < 5; i++) {
System.out.println("任务处理中... " + i);
}
}
}
// 启动方式
new MyThread().start();
实现Runnable接口是更推荐的方式。由于接口可多实现,该方式避免了继承限制,且支持任务与线程分离——同一个Runnable任务可被多个线程执行,便于资源共享。
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Runnable任务执行:" + Thread.currentThread().getName());
}
}
// 启动方式
Thread t = new Thread(new MyRunnable());
t.start();
Callable接口允许线程执行后返回结果,并可抛出受检异常。需配合FutureTask或ExecutorService使用,适用于需要获取计算结果的场景(如并行计算、异步数据预热)。
import java.util.concurrent.*;
public class MyCallable implements Callable {
@Override
public String call() throws Exception {
Thread.sleep(1000);
return "计算结果:" + Math.random();
}
}
// 启动方式
FutureTask futureTask = new FutureTask<>(new MyCallable());
new Thread(futureTask).start();
System.out.println(futureTask.get()); // 阻塞等待结果
启动线程必须调用start()而非run()。直接调用run()只是普通方法调用,不会启动新线程;而start()会向操作系统申请新线程资源,并在新线程中执行run()方法。错误示例:
// 错误:在主线程中顺序执行,无并发效果
new Thread(() -> System.out.println("A")).run();
System.out.println("B"); // 先输出B再输出A
合理命名线程有助于问题排查。默认线程名如Thread-0、pool-1-thread-1缺乏语义。可通过构造器或setName()设置:
Thread t = new Thread(() -> {}, "biz-worker-01");
t.setName("order-processor-02");
线程优先级范围为1~10(MIN_PRIORITY~MAX_PRIORITY),默认为5(NORM_PRIORITY)。但Java线程优先级依赖操作系统调度,且高优先级线程不保证先执行,仅提高调度概率。生产环境应避免过度依赖优先级调整。
多线程共享堆内存时,若多个线程同时读写同一变量且至少有一个写操作,就存在数据竞争风险。Java通过以下机制保障线程安全:
synchronized、Atomic类保证操作不可分割。volatile、synchronized、Lock确保修改对其他线程立即可见。happens-before规则与内存屏障防止指令重排序。忽视任一原则均可能导致隐性Bug。例如:未加同步的计数器累加操作可能因指令重排序导致最终值偏小。
Java线程状态由Thread.State枚举定义,包括:NEW(新建)、RUNNABLE(可运行)、BLOCKED(阻塞)、WAITING(等待)、TIMED_WAITING(超时等待)、TERMINATED(终止)。理解状态转换对调试死锁、性能瓶颈至关重要。
线程从new Thread()创建后进入NEW状态;调用start()后进入RUNNABLE(包含就绪与运行中两种子状态);当请求同步锁失败时进入BLOCKED;调用wait()、join()进入WAITING;调用sleep()、wait(timeout)进入TIMED_WAITING;执行完毕或异常退出后进入TERMINATED。
| 代码操作 | 状态变化 | 触发条件 |
|---|---|---|
new Thread() | NEW → RUNNABLE | 调用start()后由JVM调度 |
lock.lock()失败 | RUNNABLE → BLOCKED | 等待其他线程释放锁 |
obj.wait() | RUNNABLE → WAITING | 需其他线程notify()唤醒 |
Thread.sleep(1000) | RUNNABLE → TIMED_WAITING | 休眠1秒后自动恢复 |
thread.join() | RUNNABLE → WAITING | 等待目标线程终止 |
run()执行完毕 | RUNNABLE → TERMINATED | 正常退出或抛出未捕获异常 |
Java不提供强制终止线程的API(stop()已废弃),推荐使用中断协作机制:
Thread t = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
try {
// 模拟任务
Thread.sleep(100);
} catch (InterruptedException e) {
// 中断时退出循环
Thread.currentThread().interrupt(); // 恢复中断状态
}
}
});
t.start();
// 主线程发起中断
t.interrupt();
关键点:中断仅改变线程的中断标志位。阻塞方法(如sleep()、wait())会抛出InterruptedException并清除中断标志;非阻塞代码需主动检查isInterrupted()。
① suspend()/resume()已废弃:可能导致死锁(挂起线程持有锁未释放)。
② stop()已废弃:强制终止线程可能破坏对象一致性(如未完成的事务提交)。
③ yield()非可靠:仅建议当前线程让出CPU,但调度器可能立即重新分配。
正确做法:通过标志位+中断机制实现可控暂停。
频繁创建/销毁线程开销巨大(线程栈分配、上下文切换)。线程池通过复用线程、控制并发数、管理任务队列,显著提升系统稳定性。JDK提供Executors工厂类与ThreadPoolExecutor核心类。
ThreadPoolExecutor构造函数包含7个核心参数:
corePoolSize:核心线程数(常驻线程数)maximumPoolSize:最大线程数keepAliveTime:非核心线程空闲存活时间unit:时间单位workQueue:任务队列(关键参数)threadFactory:线程工厂(可命名线程)handler:拒绝策略(队列满+线程达上限时处理)有界队列:基于数组实现,容量固定。适合任务量可预估的场景。当队列满时,新任务触发创建新线程(直至maximumPoolSize)。缺点是需合理设置容量,过小易触发拒绝策略,过大可能耗尽内存。
// 典型配置(CPU密集型任务)
new ThreadPoolExecutor(
corePoolSize,
maximumPoolSize,
60L, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(100), // 容量100
new ThreadPoolExecutor.CallerRunsPolicy()
);
无界队列:基于链表实现,默认容量Integer.MAX_VALUE。当核心线程满时,新任务直接入队,不创建新线程(除非手动设置maximumPoolSize)。适用于任务突发量大但处理时间短的场景。风险是队列堆积导致OOM。
// 注意:LinkedBlockingQueue()默认无界!
Executors.newFixedThreadPool(n) // 内部使用无界队列
同步队列:无容量,生产者必须等待消费者取走任务。常用于直接提交任务给线程,不经过队列缓冲。适合高吞吐量、低延迟场景(如Netty事件处理)。
Executors.newCachedThreadPool() // 内部使用SynchronousQueue
优先队列:基于堆实现,任务按优先级排序。需任务实现Comparable或传入Comparator。适合高优任务需优先处理的场景(如告警通知、日志采样)。
new ThreadPoolExecutor(
4, 8, 30L, TimeUnit.SECONDS,
new PriorityBlockingQueue<>(200,
Comparator.comparing(Task::getPriority).reversed())
);
当队列满且线程达maximumPoolSize时,触发拒绝策略:
AbortPolicy(默认):抛出RejectedExecutionException,需捕获处理。CallerRunsPolicy:由调用线程(如主线程)执行任务,实现反压。DiscardPolicy:静默丢弃任务,适合非关键日志。DiscardOldestPolicy:丢弃队首任务,新任务入队,适合实时性要求高的场景。CPU密集型任务(如加密、压缩):
corePoolSize = CPU核心数 + 1
原因:线程数过多导致上下文切换开销大于计算收益。
I/O密集型任务(如数据库查询、文件读写):
corePoolSize = CPU核心数 × (1 + I/O耗时/计算耗时)
经验公式:通常设为CPU核心数的2~4倍。例如8核CPU处理数据库查询,可设corePoolSize=16。
混合型任务:
分离CPU与I/O任务至不同线程池,避免相互阻塞。
JMM(Java Memory Model)定义了线程如何与主内存交互,核心解决三个问题:原子性、可见性、有序性。理解JMM是编写线程安全代码的基础。
Java内存模型中,所有变量存储于主内存,线程拥有自己的工作内存(副本)。线程对变量的操作(读/写)均在工作内存进行,再同步回主内存。这导致:
① 线程A修改变量后,线程B可能读到旧值(可见性问题)
② 编译器/处理器优化可能导致指令重排序(有序性问题)
volatile提供可见性与有序性保障,但不保证原子性。典型用法:
volatile boolean stop)volatile)// 错误:非原子操作,仍需synchronized
volatile int count = 0;
count++; // 实际分三步:读→加1→写,中间可能被中断
Java定义了8条happens-before规则,确保操作顺序性:
synchronized块 happens-before 后续加锁。volatile happens-before 后续读。start() happens-before 线程内任何操作。join()返回。finalize()。| 特性 | volatile | synchronized |
|---|---|---|
| 可见性 | ✅ 保证 | ✅ 保证 |
| 原子性 | ❌ 不保证 | ✅ 保证(代码块级) |
| 阻塞 | ❌ 无阻塞 | ✅ 线程阻塞 |
| 性能 | 高(无上下文切换) | 中(JDK6后优化明显) |
| 适用场景 | 状态标记、单次写入 | 复合操作、临界区 |
Java锁体系分为内置锁(synchronized)与显式锁(java.util.concurrent.locks)。显式锁提供更灵活的控制能力。
支持公平锁与非公平锁、可中断锁、超时锁。典型用法:
ReentrantLock lock = new ReentrantLock(true); // 公平锁
lock.lock();
try {
// 临界区代码
} finally {
lock.unlock(); // 必须在finally中释放
公平锁:按请求顺序分配锁,避免线程饥饿,但吞吐量较低。
非公平锁(默认):允许插队,提升吞吐量,可能导致部分线程长期饥饿。
允许多个读线程并发,但写线程独占。适用于读多写少场景(如缓存更新)。
ReadWriteLock rwLock = new ReentrantReadWriteLock();
// 读操作(可并发)
rwLock.readLock().lock();
try {
return cache.get(key);
} finally {
rwLock.readLock().unlock();
}
// 写操作(独占)
rwLock.writeLock().lock();
try {
cache.put(key, value);
} finally {
rwLock.writeLock().unlock();
JDK8新增,提供三种模式:写锁、悲观读锁、乐观读锁。乐观读锁不阻塞写线程,适用于读操作极快的场景(如简单字段读取)。
StampedLock sl = new StampedLock();
// 乐观读(无锁,需校验stamp)
long stamp = sl.tryOptimisticRead();
if (!sl.validate(stamp)) {
stamp = sl.readLock(); // 升级为悲观读锁
try { } finally { sl.unlockRead(stamp); }
}
// 写锁
stamp = sl.writeLock();
try { } finally { sl.unlockWrite(stamp);
String常量池对象作为锁,不同类可能共享同一锁。unlock(),导致永久阻塞。synchronized可修饰方法或代码块,底层通过monitorenter/monitorexit字节码实现。JDK6后引入偏向锁、轻量级锁等优化,性能大幅提升。
锁升级过程:
无锁 → 偏向锁(单线程重入)→ 轻量级锁(自旋)→ 重量级锁(阻塞)
java.util.concurrent.atomic提供CAS(Compare-And-Swap)操作,避免锁竞争:
AtomicInteger:整型原子操作AtomicReference:对象引用原子更新AtomicStampedReference:解决ABA问题(带版本戳)LongAdder:高并发下性能优于AtomicLong(分段累加)// LongAdder高并发示例
LongAdder counter = new LongAdder();
executor.execute(() -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
});
// 最终值 = 线程数 × 10000
CAS操作中,线程A读取值为1,线程B将其改为2再改回1,A执行CAS时认为值未变(1==1),但实际中间状态已改变。解决方案:
① 使用AtomicStampedReference记录版本戳
② 业务层面避免依赖值相等性
传统集合类(如ArrayList)非线程安全,需手动同步。JDK提供并发容器,兼顾性能与安全。
JDK7使用分段锁(Segment),JDK8改为CAS + synchronized。键值对存储于Node数组,通过哈希定位桶位:
ConcurrentHashMap map = new ConcurrentHashMap<>();
map.computeIfAbsent("key", k -> 1); // 原子性put-if-absent
写时复制:每次修改创建新数组,适用于读多写少场景(如监听器列表)。写操作加锁,读操作无锁。
BlockingQueue接口实现类:
LinkedBlockingQueue:无界队列,适合生产者-消费者ArrayBlockingQueue:有界队列,内存可控DelayQueue:延迟队列(如定时任务)PriorityBlockingQueue:优先级队列| 特性 | ConcurrentHashMap | synchronizedMap |
|---|---|---|
| 锁粒度 | 桶级(JDK8)/分段(JDK7) | 整个Map |
| 读性能 | 高(无锁) | 低(需同步) |
| 迭代器 | 弱一致性(不抛ConcurrentModificationException) | 强一致性(可能抛异常) |
| 适用场景 | 高并发读写 | 低并发或需强一致性 |
允许一个或多个线程等待其他线程完成操作。典型场景:主线程等待多个子线程初始化完成。
CountDownLatch latch = new CountDownLatch(3);
ExecutorService exec = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
exec.execute(() -> {
// 初始化工作
latch.countDown(); // 计数减1
});
}
latch.await(); // 等待计数归零
System.out.println("所有初始化完成!");
允许一组线程互相等待,到达屏障点后继续执行。可重用(区别于CountDownLatch)。支持屏障动作(最后到达的线程执行)。
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
System.out.println("所有线程就位,开始合并结果!");
});
// 每个线程调用 barrier.await();
控制同时访问特定资源的线程数。典型场景:数据库连接池、限流。
Semaphore semaphore = new Semaphore(5); // 允许5个线程并发
semaphore.acquire(); // 获取许可
try { } finally {
semaphore.release(); // 释放许可
| 工具类 | 核心功能 | 典型应用 |
|---|---|---|
| CountDownLatch | 等待多个任务完成 | 主线程等待子线程初始化 |
| CyclicBarrier | 多线程相互等待 | 多线程并行计算后汇总 |
| Semaphore | 控制并发线程数 | 限流、资源池管理 |
| Exchanger | 两线程交换数据 | 生产者-消费者数据移交 |
@Contended注解填充缓存行。find deadlock)。thread -n 10查看最忙线程)。① volatile仅保证可见性与有序性,不保证原子性;synchronized两者均保证。
② volatile修饰变量无阻塞;synchronized可能阻塞线程。
③ volatile适用于状态标记;synchronized适用于复合操作。
④ volatile不会引起线程上下文切换;synchronized可能触发阻塞/唤醒。
CPU密集型:线程数 ≈ CPU核心数 + 1
I/O密集型:线程数 ≈ CPU核心数 × 2 ~ 4
混合型:分离任务至不同线程池
关键:监控队列长度、线程活跃度、拒绝次数,动态调整。
① 预防:按固定顺序加锁(如对象ID排序)
② 避免:使用tryLock()超时机制
③ 检测:jstack查看死锁信息
④ 恢复:重启服务或手动中断线程
public class Cache {
private final ConcurrentHashMap map = new ConcurrentHashMap<>();
public V get(K key) {
return map.get(key);
}
public V putIfAbsent(K key, V value) {
return map.putIfAbsent(key, value);
}
public V computeIfAbsent(K key, Function mappingFunction) {
return map.computeIfAbsent(key, k -> {
// 模拟耗时操作
return mappingFunction.apply(k);
});
}
}
说明:
① 使用ConcurrentHashMap避免同步开销
② computeIfAbsent保证原子性:若key不存在则计算并放入
③ 无显式锁,性能优于synchronized版本
以下问题常被开发者搜索,我们整理了深度解答:
需分场景讨论:
- 若线程主要执行CPU计算(如图像处理),设为CPU核心数+1即可,过多线程导致上下文切换开销增大。
- 若线程主要等待I/O(如数据库查询),可设为CPU核心数×2~4,因I/O期间CPU空闲,可调度其他线程。
- 实际最优值需压测验证:逐步增加线程数,观察吞吐量与延迟变化拐点。
JDK7的Segment采用分段锁,每个Segment持有一把锁。当多个线程访问不同Segment时可并发,但Segment内部仍需竞争锁。JDK8改用CAS + synchronized,锁粒度降至桶级别(Node),且引入红黑树优化长链表,整体并发度更高。实测显示:高并发写场景下,JDK8性能比JDK7提升30%~50%。
推荐方式:
① 使用volatile布尔标志位控制循环
② 配合中断机制:
- 在循环中检查Thread.interrupted()
- 捕获InterruptedException后退出
③ 避免使用stop()(已废弃),因其可能导致资源未释放、数据不一致。
ThreadLocalMap的Entry继承WeakReference,key(ThreadLocal实例)为弱引用,value为强引用。当ThreadLocal外部引用释放后,key被GC回收,但value仍存在(强引用链:Thread → ThreadLocalMap → Entry → value),导致value无法回收。解决方案:
① 使用后调用remove()
② 避免在线程池中使用(线程复用导致ThreadLocalMap长期存活)
步骤:
① 使用jstack <pid>生成线程堆栈
② 搜索Found one Java-level deadlock:
③ 查看死锁线程信息:等待锁、持有锁的线程
④ 分析代码:检查锁顺序是否一致(如A先锁X再锁Y,B是否反向操作)
⑤ 修复:统一锁顺序或使用tryLock()超时机制