一、线程基础全景概览
在现代计算环境中,单核CPU性能增长已趋近物理极限,多核架构成为主流。为充分挖掘硬件潜力,**并发编程**成为高性能应用开发的必修课。而**Java线程基础**正是构建可靠、高效并发系统的基石。
线程是操作系统能够进行运算调度的最小单位,被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。
Java语言从诞生之初就内置了多线程支持。JVM将线程映射到操作系统的原生线程(如Linux的futex机制),通过`java.lang.Thread`类与`java.lang.Runnable`接口提供统一抽象。理解其底层原理与上层实践,是编写高吞吐、低延迟Java应用的前提。
值得注意的是:线程并非越多越好。**线程切换开销**(上下文切换)、**锁竞争**、**内存一致性问题**(如可见性、有序性)等是并发编程中最常见的陷阱。本页面将系统梳理从基础概念到高级实践的完整知识链路,助您避开高频坑点。
以下为**java线程基础**的核心知识图谱:
- 线程创建与生命周期管理
- 线程同步机制(synchronized、volatile、Lock)
- 线程间通信(wait/notify、Condition)
- 线程池原理与参数调优
- 并发工具类(CountDownLatch、CyclicBarrier、Semaphore等)
- 线程安全容器(ConcurrentHashMap、CopyOnWriteArrayList)
- 原子变量与CAS原理
- 死锁诊断与预防策略
- JMM(Java内存模型)深度解析
后续章节将逐层深入,结合**真实业务场景**与**高频面试题**,构建完整知识体系。
1.1 为何必须掌握线程基础?
据2024年Java生态调研显示:92%的中大型应用存在多线程需求;76%的线上故障与并发问题相关;83%的Java高级工程师面试必考并发内容。**java线程基础**不仅是技术能力分水岭,更是系统稳定性、用户体验、成本控制的关键变量。
典型场景包括:
- Web服务器:Tomcat默认线程池大小为200,需根据QPS动态调整
- 数据库连接池:HikariCP通过线程池管理连接,错误配置导致连接泄漏
- 定时任务:ScheduledExecutorService替代Timer避免线程泄漏
- 异步处理:消息队列消费者线程阻塞引发积压
- 微服务调用:Feign/Ribbon的并发控制不当引发雪崩
忽视线程基础可能导致:数据不一致(如订单重复扣款)、服务假死(线程池耗尽)、内存泄漏(线程未终止)、性能瓶颈(锁粒度过粗)。
1.2 进程与线程的本质区别
| 对比维度 | 进程 | 线程 |
|---|---|---|
| 定义 | 程序执行时的实例,拥有独立内存空间 | 进程内的执行单元,共享进程资源 |
| 资源开销 | 创建/切换开销大(需分配虚拟地址空间) | 轻量级,切换开销小(仅保存寄存器/栈) |
| 通信方式 | 管道、消息队列、共享内存等IPC机制 | 直接读写共享内存,但需同步机制 |
| 隔离性 | 强隔离(一个崩溃不影响其他进程) | 弱隔离(一个线程崩溃可能使进程退出) |
| Java体现 | JVM进程对应一个操作系统进程 | 每个Thread对象映射一个原生线程 |
在Java中,通过`Runtime.getRuntime().availableProcessors()`可获取CPU核心数,合理设置线程数(CPU密集型≈核心数,IO密集型≈2×核心数)是性能优化的第一步。
二、线程创建与生命周期管理
Java中创建线程主要有三种方式:继承Thread类、实现Runnable接口、实现Callable接口。每种方式适用场景不同,需结合业务需求选择。
2.1 继承Thread类(不推荐)
由于Java单继承限制,继承Thread会占用宝贵的继承名额。示例:
class MyThread extends Thread {
@Override
public void run() {
System.out.println("当前线程:" + Thread.currentThread().getName());
}
}
public class Main {
public static void main(String[] args) {
new MyThread().start(); // 启动线程
}
}
注意:必须调用start()而非run()。直接调用run()只是普通方法调用,不会启动新线程。
2.2 实现Runnable接口(推荐)
解耦任务与线程,支持多实现,更符合面向对象设计原则:
class MyTask implements Runnable {
@Override
public void run() {
// 业务逻辑
}
}
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(new MyTask(), "worker-1");
thread.start();
}
}
配合Lambda表达式更简洁:
new Thread(() -> System.out.println("Hello Thread"), "task-1").start();
2.3 实现Callable接口(支持返回值)
适用于需要获取线程执行结果的场景,配合Future使用:
class MyCallable implements Callable {
@Override
public Integer call() {
return 123;
}
}
public class Main {
public static void main(String[] args) throws Exception {
FutureTask task = new FutureTask<>(new MyCallable());
new Thread(task).start();
System.out.println("结果:" + task.get()); // 阻塞等待结果
}
}
2.4 线程生命周期详解
Java线程状态由`Thread.State`枚举定义,包含6种状态:
| 状态 | 触发条件 | 典型场景 |
|---|---|---|
| NEW | 线程对象创建后未调用start() | new Thread()后未启动 |
| RUNNABLE | 调用start()后,等待CPU调度 | 线程池中活跃线程 |
| BLOCKED | 等待进入synchronized块/方法 | 锁竞争激烈时线程阻塞 |
| WAITING | 调用无参wait()、join()、LockSupport.park() | 线程间通信等待通知 |
| TIMED_WAITING | 调用带参wait(timeout)、sleep()、join(timeout) | 定时任务线程休眠 |
| TERMINATED | run()方法执行完毕 | 线程自然结束 |
2.5 线程中断机制
Java不推荐使用stop()强制终止线程(可能导致资源泄漏),应使用**中断协作机制**:
- interrupt():设置中断标志位
- isInterrupted():检查中断状态(不清除)
- interrupted():静态方法,检查并清除中断状态
正确处理中断的示例:
public void run() {
try {
while (!Thread.currentThread().isInterrupted()) {
// 执行任务
Thread.sleep(1000);
}
} catch (InterruptedException e) {
// 恢复中断状态
Thread.currentThread().interrupt();
System.out.println("线程被中断");
}
}
关键点:捕获InterruptedException后必须恢复中断状态(调用interrupt()),否则会丢失中断信号。
2.6 守护线程(Daemon Thread)
通过`setDaemon(true)`设置。当所有非守护线程结束时,JVM会自动退出,守护线程随之终止。典型应用:GC线程、日志线程。
Thread daemon = new Thread(() -> {
while (true) {
System.out.println("守护线程运行中...");
try { Thread.sleep(1000); } catch (InterruptedException e) {}
}
});
daemon.setDaemon(true);
daemon.start();
注意:守护线程内创建的子线程默认也是守护线程。
三、线程同步机制深度解析
并发问题的根源在于**共享数据的非原子性操作**。Java提供多种同步机制确保线程安全:synchronized、volatile、显式锁(Lock)、原子变量(Atomic)。
3.1 synchronized关键字
三种使用方式:
| 方式 | 锁对象 | 适用场景 |
|---|---|---|
| 同步实例方法 | 当前实例对象(this) | 保护实例状态 |
| 同步静态方法 | 当前类的Class对象 | 保护静态资源 |
| 同步代码块 | 指定对象(任意) | 精确控制锁粒度 |
示例:同步代码块避免锁竞争
public void updateCounter() {
synchronized(this) { // 仅同步关键部分
counter++;
}
// 非关键逻辑不阻塞其他线程
log.info("Counter updated: " + counter);
}
3.2 volatile关键字
提供可见性保障,确保变量修改对所有线程立即可见。但不保证原子性(如i++仍是非原子操作)。
典型应用场景:
- 状态标志(如shutdownFlag)
- DCL单例模式中的instance字段
- 避免指令重排序(结合happens-before原则)
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(); // 非原子操作,volatile防止重排序
}
}
}
return instance;
}
}
无volatile时,`new Singleton()`可能被重排序为:1.分配内存→2.设置instance指向内存→3.初始化对象。其他线程可能看到未初始化完成的对象。
3.3 显式锁(Lock)
Lock接口(如ReentrantLock)提供比synchronized更灵活的锁机制:
- 可中断锁获取(lockInterruptibly())
- 超时锁获取(tryLock(timeout))
- 公平锁支持(new ReentrantLock(true))
- 条件变量(Condition)替代wait/notify
示例:使用Condition实现生产者-消费者
class BoundedBuffer {
private final Lock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
private final Object[] items = new Object[10];
private int count, putIndex, takeIndex;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putIndex] = x;
if (++putIndex == items.length) putIndex = 0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeIndex];
if (++takeIndex == items.length) takeIndex = 0;
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}
3.4 原子变量(Atomic)
基于CAS(Compare-And-Swap)机制实现无锁并发,适用于简单计数场景:
| 类 | 功能 | 示例 |
|---|---|---|
| AtomicInteger | 整型原子操作 | counter.incrementAndGet() |
| AtomicLong | 长整型原子操作 | counter.addAndGet(100) |
| AtomicReference | 对象引用原子更新 | ref.compareAndSet(old, new) |
| AtomicStampedReference | 解决ABA问题 | 带版本戳的CAS操作 |
CAS原理:通过CPU指令(如cmpxchg)实现原子更新,避免线程阻塞。但存在ABA问题(值从A→B→A),需用版本戳解决。
四、线程池原理与参数调优
线程池是并发编程的核心组件,避免频繁创建/销毁线程的开销。Java通过Executor框架提供统一接口。
4.1 线程池核心参数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
| 参数 | 说明 | 推荐值 |
|---|---|---|
| corePoolSize | 核心线程数 | CPU密集型≈核心数;IO密集型≈2×核心数 |
| maximumPoolSize | 最大线程数 | 核心数×(1+IO等待时间/计算时间) |
| keepAliveTime | 非核心线程存活时间 | 30秒(通用) |
| workQueue | 任务队列 | SynchronousQueue(快速响应)/LinkedBlockingQueue(高吞吐) |
| handler | 拒绝策略 | CallerRunsPolicy(回压)/AbortPolicy(快速失败) |
4.2 线程池工作流程
当新任务提交时:
- 当前线程数 < corePoolSize → 创建新线程处理
- 当前线程数 ≥ corePoolSize → 任务进入队列
- 队列满且线程数 < maximumPoolSize → 创建新线程
- 线程数已达最大 → 执行拒绝策略
示例:自定义线程池(防止OOM)
ExecutorService executor = new ThreadPoolExecutor(
4, // corePoolSize
8, // maximumPoolSize
30L, TimeUnit.SECONDS,
new SynchronousQueue<>(), // 无缓冲队列
new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
new ThreadPoolExecutor.CallerRunsPolicy() // 回压策略
);
避免使用Executors静态工厂(如newFixedThreadPool),因其使用无界队列可能导致OOM。
4.3 常见线程池类型对比
| 类型 | 核心参数 | 适用场景 | 风险 |
|---|---|---|---|
| FixedThreadPool | core=max, 无界队列 | 任务量稳定、耗时短 | 任务堆积导致OOM |
| CachedThreadPool | core=0, max=Integer.MAX | 大量短生命周期任务 | 线程数爆炸 |
| SingleThreadExecutor | core=max=1, 无界队列 | 顺序执行任务 | 任务堆积导致OOM |
| ScheduledThreadPool | 支持定时/周期任务 | 定时任务、心跳检测 | 任务延迟累积 |
生产环境建议:自定义ThreadPoolExecutor,明确参数边界。
五、并发工具类实战指南
JUC(java.util.concurrent)提供了丰富的并发工具,简化复杂同步逻辑。
5.1 CountDownLatch(倒计时门栓)
允许一个或多个线程等待其他线程完成操作。典型场景:主线程等待多个子线程初始化完成。
CountDownLatch latch = new CountDownLatch(3);
// 子线程1
new Thread(() -> {
// 初始化操作
latch.countDown();
}).start();
// 主线程等待
latch.await();
System.out.println("所有初始化完成!");
5.2 CyclicBarrier(循环栅栏)
一组线程等待到达屏障点后继续执行,可重用。典型场景:多线程计算数据后合并结果。
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
System.out.println("所有线程到达屏障,执行汇总!");
});
// 三个线程
for (int i = 0; i < 3; i++) {
new Thread(() -> {
// 计算操作
barrier.await(); // 等待其他线程
// 汇总结果
}).start();
}
5.3 Semaphore(信号量)
控制同时访问特定资源的线程数。典型场景:数据库连接池、限流。
Semaphore semaphore = new Semaphore(5); // 5个许可证
// 获取许可证
semaphore.acquire();
try {
// 访问资源
} finally {
semaphore.release(); // 必须释放
}
5.4 Future与CompletableFuture
CompletableFuture提供异步编程API,支持函数式组合:
CompletableFuture future = CompletableFuture
.supplyAsync(() -> "Hello")
.thenApply(s -> s + " World")
.thenCompose(s -> CompletableFuture
.supplyAsync(() -> s + "!"))
.exceptionally(ex -> "Error: " + ex.getMessage());
System.out.println(future.get()); // Hello World!
优势:避免回调地狱,支持链式调用,自动处理异常。
六、线程安全与JMM深度解析
6.1 线程安全的三大问题
| 问题 | 原因 | 解决方案 |
|---|---|---|
| 原子性 | 多线程执行非原子操作 | synchronized、Atomic、Lock |
| 可见性 | 线程工作内存与主内存不同步 | volatile、synchronized、Lock |
| 有序性 | 指令重排序导致逻辑错误 | volatile、happens-before规则 |
6.2 Java内存模型(JMM)核心规则
JMM定义了线程与主内存的交互协议,通过happens-before原则保证内存可见性:
- 程序次序规则:线程内代码按序happens-before
- 监视器锁规则:解锁synchronized前happens-before后续加锁
- volatile变量规则:写volatile前happens-before后续读
- 线程启动规则:start()前happens-before新线程执行
- 线程终止规则:线程内所有操作happens-before join()返回
- 中断规则:interrupt()前happens-before检测到中断
- 终结器规则:对象构造前happens-beforefinalize()
示例:volatile确保可见性
class VolatileExample {
volatile boolean initialized = false;
Data data;
void init() {
data = new Data(); // 1. 分配内存
initialized = true; // 2. 设置标志(happens-before后续读)
}
void use() {
if (initialized) {
// 保证看到完整初始化的data
process(data);
}
}
}
6.3 常见线程安全容器
| 容器 | 线程安全特性 | 适用场景 |
|---|---|---|
| ConcurrentHashMap | 分段锁(JDK8+ CAS+synchronized) | 高并发读写Map |
| CopyOnWriteArrayList | 写时复制(加锁+数组复制) | 读多写少(如监听器列表) |
| ConcurrentLinkedQueue | 无锁CAS实现 | 高吞吐队列 |
| BlockingQueue | 生产者-消费者模型 | 任务队列、消息缓冲 |
七、并发性能优化策略
7.1 锁优化技巧
- 减小锁粒度:拆分锁(如ConcurrentHashMap的分段锁)
- 锁分离:读写锁(ReadWriteLock)分离读写操作
- 锁粗化:连续加锁合并为一次(如StringBuilder)
- 偏向锁/轻量级锁:JVM自动优化(JDK6+)
- 避免锁竞争:使用ThreadLocal隔离线程状态
7.2 避免死锁的实践
死锁四条件:互斥、占有且等待、不可抢占、循环等待。预防策略:
- 固定加锁顺序(如按对象哈希码排序)
- 使用tryLock(timeout)避免无限等待
- 减少锁持有时间(只同步关键代码)
- 使用同步工具类(如CountDownLatch)替代手动锁
死锁诊断命令:
jstack -l [pid] | grep -A 10 "Found.*deadlock"
7.3 上下文切换优化
频繁切换导致CPU缓存失效。优化方法:
- 减少线程数(避免超过CPU核心数2倍)
- 使用线程池复用线程
- 避免忙等待(用wait/notify或park)
- 使用无锁算法(如CAS)
监控命令:
vmstat 1 | awk '{print $15}' # cs列:上下文切换次数/秒
八、真实业务案例解析
8.1 订单超时取消
问题:用户下单后30分钟未支付则自动取消订单。
错误做法:为每个订单创建Timer(线程泄漏风险)。
正确方案:使用DelayQueue(优先级队列)+ 单线程消费者
class OrderTask implements Delayed {
private final String orderId;
private final long expireTime;
@Override
public long getDelay(TimeUnit unit) {
return unit.convert(expireTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
}
@Override
public int compareTo(Delayed o) {
return Long.compare(this.expireTime, ((OrderTask)o).expireTime);
}
}
// 消费者
new Thread(() -> {
while (!Thread.interrupted()) {
try {
OrderTask task = delayQueue.take();
cancelOrder(task.getOrderId());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}).start();
8.2 批量数据导出
问题:10万条数据导出,单线程耗时过长。
优化方案:分页查询 + 线程池并行处理
int total = 100000;
int batchSize = 1000;
int pages = (total + batchSize - 1) / batchSize;
ExecutorService pool = new ThreadPoolExecutor(
8, 16, 30L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100),
new ThreadFactoryBuilder().setNameFormat("export-%d").build(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
CountDownLatch latch = new CountDownLatch(pages);
for (int i = 0; i < pages; i++) {
int page = i;
pool.submit(() -> {
try {
List batch = queryBatch(page * batchSize, batchSize);
exportBatch(batch);
} finally {
latch.countDown();
}
});
}
latch.await(); // 等待全部完成
pool.shutdown();
注意:导出文件需线程安全(如使用ThreadLocal的BufferedWriter)。
九、高频面试题精解
9.1 synchronized与ReentrantLock区别
- 实现层面:synchronized是JVM关键字;ReentrantLock是API
- 功能差异:ReentrantLock支持公平锁、超时锁、条件变量
- 性能:JDK6后synchronized优化显著,多数场景性能相当
- 使用建议:简单同步用synchronized;复杂控制用Lock
9.2 volatile能否保证原子性?
不能。volatile仅保证可见性和有序性,不保证原子性。如i++包含读-改-写三步,需用AtomicInteger。
9.3 线程池拒绝策略选择
| 策略 | 行为 | 适用场景 |
|---|---|---|
| AbortPolicy | 抛异常 | 测试环境(快速失败) |
| CallerRunsPolicy | 调用者线程执行 | 生产环境(限流回压) |
| DiscardPolicy | 静默丢弃 | 可容忍丢弃的场景 |
| DiscardOldestPolicy | 丢弃队列头任务 | 实时性要求高的任务 |
十、网友最关心问题答疑
线程池大小设置公式
根据任务类型调整:
- CPU密集型:corePoolSize ≈ CPU核心数 + 1
- IO密集型:corePoolSize ≈ CPU核心数 × (1 + IO耗时/计算耗时)
- 混合型:按主要类型调整,或拆分线程池
实测建议:通过压测工具(JMeter)逐步增加线程数,观察TPS拐点。
volatile与synchronized性能
JDK6后synchronized引入偏向锁/轻量级锁,性能大幅提升:
| 场景 | synchronized | volatile |
|---|---|---|
| 无竞争 | 极快(偏向锁) | 快(仅内存屏障) |
| 低竞争 | 快(自旋锁) | 快 |
| 高竞争 | 中等(阻塞) | 慢(CAS失败重试) |
结论:优先用synchronized;高竞争计数场景用Atomic。
死锁诊断步骤
- 用jps定位Java进程ID
- 执行jstack -l [pid] > dump.txt
- 搜索"Found 1 deadlock"
- 分析堆栈:找到持锁线程与等待线程
- 用jconsole可视化监控线程状态
预防:统一加锁顺序 + 减少锁嵌套 + 使用tryLock超时。
ThreadLocal内存泄漏
ThreadLocalMap使用弱引用持有key,但value是强引用:
- 线程结束 → ThreadLocalMap清除 → 无泄漏
- 线程复用(线程池)→ key被GC → value无法访问 → 泄漏
解决方案:使用后调用remove();线程池中避免复用ThreadLocal。