java多线程编程学习
在当今分布式高并发系统架构中,Java多线程编程已成为构建高性能、高可用后端服务的基石能力。无论是电商秒杀系统、实时数据处理引擎,还是微服务网关与消息中间件,其底层无不依赖于对线程的精准控制与高效调度。掌握多线程技术,不仅关乎代码执行效率,更直接影响系统稳定性、资源利用率与用户体验。
本页面系统梳理了Java并发编程的核心知识体系,从线程生命周期管理、线程同步机制、线程池优化策略,到Java内存模型(JMM)、并发工具类实战应用,结合真实场景案例与高频面试题解析,帮助开发者构建完整的并发编程认知框架。
当前互联网应用普遍面临“高并发”挑战:单机QPS动辄数万,用户请求延迟需控制在毫秒级,资源竞争冲突频繁。若缺乏并发意识,轻则导致系统响应缓慢、吞吐量下降,重则引发死锁、数据不一致、服务雪崩等严重故障。因此,深入理解多线程原理,是避免“并发陷阱”、实现系统稳定性的关键保障。
本学习路径覆盖以下核心能力模块:
- • 线程创建与生命周期管理(Thread/Runnable/Callable)
- • 线程安全三大特性:原子性、可见性、有序性
- • synchronized与Lock体系深度解析
- • volatile关键字原理与内存语义
- • 线程池参数调优与拒绝策略设计
- • 并发工具类(CountDownLatch/CyclicBarrier/Phaser/ Semaphore)实战
- • Java内存模型(JMM)与happens-before规则
- • ThreadLocal原理、内存泄漏风险与最佳实践
- • CAS原理与Atomic类家族应用
- • 并发编程常见问题诊断与调优方法
建议学习顺序:先掌握线程基础与同步机制,再深入内存模型原理,最后通过实战项目巩固能力。每个知识点均配备可运行的代码示例与典型错误场景分析,帮助开发者从“能用”进阶到“用好”。无论你是初级工程师夯实基础,还是高级开发应对架构设计挑战,本内容均具高度实用价值。
一、线程基础:从创建到生命周期
在Java中,线程是CPU调度的最小单位。理解线程的创建方式与生命周期,是并发编程的第一步。
1.1 线程创建的三种主流方式
- • 继承Thread类:重写run()方法,调用start()启动线程。缺点:单继承限制,无法继承其他类。
- • 实现Runnable接口:将任务逻辑与线程分离,更灵活,推荐优先使用。
- • 实现Callable接口 + Future:支持返回值与异常抛出,常配合线程池使用。
1.2 线程生命周期状态
Java线程有6种状态(Thread.State):
- NEW:线程刚创建,尚未调用start()。
- RUNNABLE:调用start()后进入此状态,包含“就绪”与“运行中”两种子状态。
- BLOCKED:等待获取synchronized锁时进入(排他锁阻塞)。
- WAITING:调用Object.wait()、Thread.join()等无参方法进入,需其他线程显式唤醒。
- TIMED_WAITING:调用Thread.sleep()、wait(long)、join(long)等带超时方法进入。
- TERMINATED:run()方法执行完毕或异常退出,线程结束。
1.3 线程中断机制详解
Thread.interrupt()仅设置中断标志位,不强制终止线程。正确中断方式:
- • 在循环中检查Thread.currentThread().isInterrupted(),主动退出。
- • 在阻塞方法(如sleep、wait)中,会抛出InterruptedException并清除中断状态。
- • 避免使用已废弃的stop()、suspend()方法,易导致死锁。
示例:安全中断线程
public class SafeInterrupt implements Runnable {
@Override
public void run() {
while (!Thread.currentThread().isInterrupted()) {
try {
// 模拟业务处理
Thread.sleep(100);
} catch (InterruptedException e) {
// 恢复中断状态
Thread.currentThread().interrupt();
break;
}
}
System.out.println("线程已安全退出");
}
}
二、线程同步:保障数据一致性
多线程环境下,共享数据的并发访问可能导致脏读、丢失更新等问题。同步机制确保同一时刻仅一个线程访问临界区。
2.1 synchronized关键字
三种使用形式:
- • 实例方法:锁当前对象实例(this)
- • 静态方法:锁当前类的Class对象
- • 同步代码块:显式指定锁对象(推荐,粒度更细)
注意:锁对象必须是同一个实例,否则同步失效。
示例:银行转账同步实现
public class Account {
private int balance = 1000;
public void transfer(Account target, int amount) {
synchronized (this) { // 锁当前对象
if (balance >= amount) {
balance -= amount;
target.balance += amount;
}
}
}
}
2.2 ReentrantLock与读写锁
相比synchronized,Lock提供更灵活的锁控制:
- • 尝试获取锁:tryLock()支持超时与中断响应
- • 可中断锁获取:lockInterruptibly()
- • 公平锁支持:new ReentrantLock(true)
- • 读写分离:ReadWriteLock允许多个读线程并发
示例:使用读写锁优化缓存
public class Cache {
private final Map map = new HashMap<>();
private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
public V get(K key) {
rwLock.readLock().lock();
try {
return map.get(key);
} finally {
rwLock.readLock().unlock();
}
}
public void put(K key, V value) {
rwLock.writeLock().lock();
try {
map.put(key, value);
} finally {
rwLock.writeLock().unlock();
}
}
}
2.3 原子类与CAS机制
java.util.concurrent.atomic包提供无锁并发方案:
- • 基础类:AtomicInteger/AtomicLong/AtomicBoolean
- • 数组类:AtomicIntegerArray
- • 引用类:AtomicReference
- • 原子更新字段:AtomicIntegerFieldUpdater
底层基于Unsafe类的CAS(Compare-And-Swap)操作,避免线程阻塞,适合低竞争场景。
示例:计数器原子递增
public class Counter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet(); // 原子操作
}
public int getValue() {
return count.get();
}
}
三、线程池:高效资源管理
频繁创建/销毁线程开销大,线程池复用线程,提升系统吞吐量与响应速度。
3.1 线程池核心参数解析
ThreadPoolExecutor构造参数:
- • corePoolSize:核心线程数(常驻线程)
- • maximumPoolSize:最大线程数
- • keepAliveTime:非核心线程空闲存活时间
- • unit:时间单位
- • workQueue:任务队列(阻塞队列)
- • threadFactory:线程创建工厂(可命名线程)
- • handler:拒绝策略(队列满时处理方式)
3.2 四种拒绝策略
| 策略 | 行为 | 适用场景 |
|---|---|---|
| AbortPolicy | 抛出RejectedExecutionException | 默认策略,快速失败 |
| CallerRunsPolicy | 由调用线程执行任务 | 允许任务延迟执行 |
| DiscardPolicy | 直接丢弃任务 | 允许任务丢失 |
| DiscardOldestPolicy | 丢弃队列 oldest 任务 | 保证新任务执行 |
3.3 阻塞队列类型对比
- • ArrayBlockingQueue:有界数组队列,FIFO
- • LinkedBlockingQueue:有界/无界链表队列(默认无界)
- • SynchronousQueue:不存储元素,直接移交任务
- • PriorityBlockingQueue:优先级队列
- • DelayQueue:延迟队列
线程池推荐配置:
- • CPU密集型任务:corePoolSize = CPU核心数 + 1
- • IO密集型任务:corePoolSize = CPU核心数 × 2
- • 混合型任务:拆分线程池分别处理
3.4 线程池生命周期管理
关键方法:
- • shutdown():平滑关闭,不接受新任务,等待已提交任务完成
- • shutdownNow():强制关闭,尝试中断线程,返回未执行任务
- • awaitTermination():阻塞等待线程池终止
最佳实践:使用try-finally确保资源释放
ExecutorService pool = Executors.newFixedThreadPool(4);
try {
// 提交任务
pool.submit(() -> System.out.println("执行中"));
} finally {
pool.shutdown();
}
四、并发工具类:提升开发效率
JDK并发包提供多种同步辅助类,简化复杂并发场景实现。
4.1 CountDownLatch:倒计时门栓
用于等待多个线程完成后再继续执行(主线程等待子线程)。
典型场景:多线程初始化后启动服务
public class InitService {
public void start() {
int threadCount = 3;
CountDownLatch latch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
try {
// 模拟初始化
Thread.sleep(500);
System.out.println("服务初始化完成");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
latch.countDown();
}
}).start();
}
try {
latch.await(); // 等待所有初始化完成
System.out.println("所有服务启动完毕!");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
4.2 CyclicBarrier:循环屏障
多个线程相互等待,到达屏障点后继续执行(线程间同步)。
与CountDownLatch区别:CyclicBarrier可复用,支持屏障动作。
典型场景:多线程计算后汇总结果
public class CyclicBarrierDemo {
public static void main(String[] args) {
int threadCount = 3;
CyclicBarrier barrier = new CyclicBarrier(threadCount, () -> {
System.out.println("所有线程到达屏障点,执行汇总");
});
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
try {
System.out.println("线程" + Thread.currentThread().getName() + "计算中...");
Thread.sleep(1000);
barrier.await(); // 等待其他线程
System.out.println("线程" + Thread.currentThread().getName() + "继续执行");
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
}
}
4.3 Semaphore:信号量
控制同时访问特定资源的线程数量(限流)。
典型场景:数据库连接池、限流器
public class RateLimiter {
private final Semaphore semaphore = new Semaphore(5); // 最多5个并发
public void accessResource() {
try {
semaphore.acquire(); // 获取许可
// 模拟资源访问
System.out.println(Thread.currentThread().getName() + "正在访问资源");
Thread.sleep(2000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
semaphore.release(); // 释放许可
}
}
}
4.4 Phaser:可重用屏障
支持动态注册/注销线程,支持多阶段同步。
相比CyclicBarrier更灵活,适用于多阶段任务协调。
五、Java内存模型:并发正确性的根基
JMM(Java Memory Model)定义了线程如何与主内存交互,保障并发程序的正确性。
5.1 JMM三大特性
- • 原子性:由synchronized与Lock保证(不可分割操作)
- • 可见性:由volatile、synchronized、final保证(线程间可见)
- • 有序性:由happens-before规则保证(禁止指令重排序)
5.2 volatile关键字深度解析
作用:保证可见性 + 禁止指令重排序(不保证原子性)
典型应用:
- • 状态标记:boolean flag = true;
- • DCL单例模式
- • 双重检查锁(Double-Checked Locking)
示例:安全的DCL单例
public class Singleton {
private volatile static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton(); // volatile防止重排序
}
}
}
return instance;
}
}
5.3 happens-before规则
Java内存模型定义的12条happens-before规则中,最常用:
- • 程序顺序规则:单线程内,按代码顺序
- • 监视器锁规则:unlock() happens-before 后续的lock()
- • volatile变量规则:写 happens-before 后续的读
- • 线程启动规则:start() happens-before 线程内任何操作
- • 线程终止规则:线程内所有操作 happens-before join()返回
- • 中断规则:interrupt() happens-before 检测到中断
- • 传递性:A→B, B→C ⇒ A→C
5.4 内存屏障类型
| 屏障类型 | 作用 | 对应指令 |
|---|---|---|
| LoadLoad | 禁止读操作重排序 | Load1; LoadLoad; Load2 |
| StoreStore | 禁止写操作重排序 | Store1; StoreStore; Store2 |
| LoadStore | 禁止读→写重排序 | Load; LoadStore; Store |
| StoreLoad | 禁止写→读重排序(最重) | Store; StoreLoad; Load |
六、实战案例:高并发场景解析
理论需结合实践才能内化为能力。以下分析三个典型高并发问题及解决方案。
6.1 订单超卖问题
问题描述:库存10件,100人同时抢购,出现超卖(卖出12件)
原因分析:库存读取与扣减非原子操作,多个线程同时读到库存10,均执行成功
解决方案:
- • 数据库层:使用UPDATE stock = stock - 1 WHERE id = ? AND stock > 0
- • Redis层:Lua脚本保证原子性
- • JVM层:synchronized或AtomicInteger
Redis Lua脚本示例:
local stock = redis.call('GET', KEYS[1])
if tonumber(stock) > tonumber(ARGV[1]) then
redis.call('DECR', KEYS[1])
return 1
else
return 0
end
6.2 线程死锁诊断
死锁四要素:互斥、占有且等待、不可剥夺、循环等待
示例死锁代码:
public class DeadLock {
private final Object lockA = new Object();
private final Object lockB = new Object();
public void method1() {
synchronized (lockA) {
Thread.sleep(100);
synchronized (lockB) { ... } // 等待lockB
}
}
public void method2() {
synchronized (lockB) {
Thread.sleep(100);
synchronized (lockA) { ... } // 等待lockA
}
}
}
诊断工具:
- • jstack -l [pid]:查看线程栈与死锁信息
- • jvisualvm:图形化分析
- • Arthas:在线诊断
预防策略:
- • 统一锁顺序(避免循环等待)
- • 使用tryLock()超时机制
- • 减少锁持有时间
- • 使用无锁数据结构
6.3 线程池拒绝策略实战
场景:秒杀系统瞬时流量峰值远超系统承载能力
配置方案:
- • 核心线程数:8(满足基本处理能力)
- • 最大线程数:16(突发流量扩容)
- • 队列:ArrayBlockingQueue(100)(有界队列防OOM)
- • 拒绝策略:CallerRunsPolicy(回压机制,避免雪崩)
效果:当系统过载时,调用线程(如HTTP请求线程)直接执行任务,自然降低请求速率,实现限流。
七、高频面试题:系统级准备
以下是开发者面试中关于多线程的高频问题与深度解答。
7.1 synchronized与ReentrantLock区别
- • 语法:synchronized是关键字,Lock是接口
- • 锁释放:synchronized自动释放,Lock需手动unlock()
- • 功能:Lock支持尝试获取、可中断、公平锁、读写锁
- • 性能:JDK6后synchronized优化显著,低竞争下性能相当
- • 选择:简单同步用synchronized,高级需求用Lock
7.2 volatile与synchronized对比
| 特性 | volatile | synchronized |
|---|---|---|
| 原子性 | 不保证(除long/double) | 保证 |
| 可见性 | 保证 | 保证 |
| 有序性 | 禁止重排序 | 互斥执行 |
| 阻塞 | 不阻塞 | 阻塞线程 |
| 适用场景 | 状态标记、双检锁 | 复杂同步逻辑 |
7.3 线程池参数如何调优
调优三步法:
- • 监控指标:CPU使用率、线程数、队列长度、任务执行时间
- • 调整策略:根据监控数据分阶段调整参数
- • 验证效果:使用JMH进行基准测试
经验公式:corePoolSize = CPU核心数 × (1 + (IO耗时/CPU耗时))
7.4 ThreadLocal内存泄漏原因
ThreadLocalMap的Entry继承WeakReference,key为弱引用,value为强引用。
当ThreadLocal对象被回收后,key变为null,但value仍被强引用,若线程长期存活,导致value无法回收。
解决方案:
- • 使用后及时调用remove()
- • 避免在长生命周期线程中使用(如线程池)
- • 自定义ThreadLocal子类重写remove()