在当今高并发互联网系统中,java并发编程已成为后端工程师必须掌握的核心能力之一。从秒杀系统到实时数据处理,从分布式服务通信到高吞吐消息队列,底层都依赖于对线程调度、资源竞争、内存模型等并发机制的精准控制。
本指南面向具备基础Java语法知识的开发者,系统梳理并发编程的关键知识点,结合真实工程实践,帮助您构建完整的并发知识体系。内容覆盖从线程创建与生命周期、同步机制原理、JMM内存模型、并发工具类使用,到线程池设计、锁优化策略、性能调优等进阶主题,每一环节均配有可运行的代码示例与常见误区解析。
学习本课程后,您将能够:
并发编程不是“锦上添花”的技能,而是构建高可用、高并发系统的基石。据2025年Stack Overflow开发者调查,超过78%的Java后端开发者将并发问题列为最困扰他们的技术难点之一。而系统性学习本指南内容,可显著降低此类问题的发生率。
在深入同步机制前,必须厘清线程的底层行为。线程是CPU执行调度的基本单位,其本质是“共享进程资源的独立执行流”。在JVM中,每个线程拥有独立的栈空间(存储局部变量、操作数栈、帧数据),但共享堆内存与方法区。这种资源隔离与共享的混合模式,正是并发Bug频发的根本原因。
Java线程状态由Thread.State枚举定义,对应JVM规范中的五种状态:
常见误区:线程状态为RUNNABLE时,不代表一定在执行代码——它可能正等待I/O或等待其他资源。可通过jstack工具查看线程实际阻塞点。
class MyThread extends Thread {
public void run() {
System.out.println("线程执行中...");
}
}
new MyThread().start();
class MyTask implements Runnable {
public void run() {
System.out.println("任务执行中...");
}
}
new Thread(new MyTask()).start();
new Thread(() -> {
System.out.println("Lambda任务执行...");
}).start();
推荐优先使用Runnable或Lambda方式,因其支持任务与线程分离,便于线程池复用。继承Thread会限制类的扩展性(Java单继承)。
中断是协作式机制,非强制终止线程。核心方法:
正确处理中断的示例:
while (!Thread.currentThread().isInterrupted()) {
try {
// 执行业务逻辑
Thread.sleep(1000);
} catch (InterruptedException e) {
// 恢复中断状态
Thread.currentThread().interrupt();
break;
}
}
注意:调用sleep()、wait()等阻塞方法时,线程会立即响应中断并抛出InterruptedException,此时必须处理中断状态以避免丢失中断信号。
Java内存模型(JMM)定义了线程如何访问共享变量。关键原则:
典型反例:双重检查锁定单例的错误写法(未加volatile)
class Singleton {
private static Singleton instance; // 缺少volatile!
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null)
instance = new Singleton(); // 可能重排序导致未完全初始化
}
}
return instance;
}
}
修正方案:将instance声明为volatile
synchronized通过对象监视器(Monitor)实现同步。其底层机制:
适用场景:
volatile仅保证可见性与有序性,不保证原子性。典型用例:
错误示例(非原子操作):
volatile int count = 0;
// 多线程执行:count++ 仍会导致计数丢失
正确替代方案:使用AtomicInteger
用于等待多个线程完成后再继续执行。典型场景:主线程等待所有子线程初始化完成。
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
new Thread(() -> {
System.out.println("子线程执行...");
latch.countDown();
}).start();
}
latch.await(); // 阻塞直到计数为0
System.out.println("所有子线程完成!");
注意:计数器不可重置,一次性的。
所有线程到达屏障点后一起继续执行。支持重置,可设置barrierAction在屏障点执行。
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
System.out.println("所有线程就位,开始计算!");
});
for (int i = 0; i < 3; i++) {
new Thread(() -> {
try {
System.out.println("线程" + Thread.currentThread().getName() + "就位");
barrier.await();
System.out.println("线程继续执行");
} catch (Exception e) { e.printStackTrace(); }
}).start();
}
控制同时访问特定资源的线程数。常用于连接池、流量控制。
Semaphore sem = new Semaphore(2); // 仅允许2个线程同时访问
for (int i = 0; i < 5; i++) {
new Thread(() -> {
try {
sem.acquire();
System.out.println("获取许可,执行中...");
Thread.sleep(1000);
} catch (InterruptedException e) { e.printStackTrace(); }
finally { sem.release(); }
}).start();
}
JDK8采用CAS+synchronized优化,分段锁升级为桶级锁。关键特性:
注意:size()方法返回近似值(因并发修改),精确计数需用LongAdder。
线程池通过复用线程减少创建开销。核心参数:
| 参数 | 说明 | 推荐值 |
|---|---|---|
| corePoolSize | 核心线程数 | CPU核心数+1(CPU密集型) 或2×CPU核心数(IO密集型) |
| maximumPoolSize | 最大线程数 | 根据队列容量与任务特性调整 |
| keepAliveTime | 非核心线程存活时间 | 60秒(默认) |
| workQueue | 任务队列 | LinkedBlockingQueue(无界) 或ArrayBlockingQueue(有界) |
推荐使用Executors工具类的预设线程池,或自定义ThreadPoolExecutor避免OOM风险:
ExecutorService pool = new ThreadPoolExecutor(
4, 8, 60L, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(100),
new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
当队列满且线程达最大值时触发拒绝策略:
生产环境推荐CallerRunsPolicy,可反压上游服务。
排查工具:
仅同步必要代码块,避免同步整个方法
使用分段锁(如ConcurrentHashMap的segment)
用ReentrantReadWriteLock替代synchronized
循环内多次加锁 → 合并到循环外
解决方案:
核心挑战:库存超卖、请求积压、服务雪崩
使用Disruptor或自定义线程池异步刷盘:
public class AsyncLogger {
private final ExecutorService executor = Executors.newSingleThreadExecutor();
public void log(String msg) {
executor.execute(() -> {
// 磁盘I/O操作
Files.write(Paths.get("app.log"),
(msg + "\n").getBytes(),
StandardOpenOption.APPEND);
});
}
}
注意:需处理队列满时的拒绝策略,避免OOM。
并发编程需循序渐进:先理解线程基础 → 掌握同步原语 → 熟悉工具类 → 深入源码原理 → 实战调优。切忌跳过基础直接研究源码。
“并发不是越多线程越好!线程数 = CPU核心数 × (1 + 等待时间/计算时间)。过度并发反而降低吞吐量。
最后提醒:所有并发问题必须复现才能修复。建议在测试环境用JMH(Java Microbenchmark Harness)进行基准测试,避免生产环境“试错”。