Java 多线程核心知识体系整理
1. 多线程基础概念与生命周期
多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程来执行不同的任务 。在 Java 中,线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位 。
线程生命周期状态
Java 线程具有明确的生命周期状态,主要包括新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked/Waiting)和死亡(Terminated) 。理解这些状态对于排查死锁和优化线程调度至关重要 。
| 状态 | 描述 | 触发条件 |
|---|---|---|
| NEW | 新建状态 | 创建线程对象后,尚未调用 start() 方法 |
| RUNNABLE | 就绪/运行状态 | 调用 start() 后,等待 CPU 时间片或正在执行中 |
| BLOCKED | 阻塞状态 | 等待获取监视器锁(synchronized)进入同步块 |
| WAITING | 无限等待状态 | 调用 wait(), join(), LockSupport.park() 且无超时 |
| TIMED_WAITING | 限时等待状态 | 调用带超时参数的 sleep(), wait(), join() 等 |
| TERMINATED | 终止状态 | 线程执行完毕或因异常退出 |
2. 线程创建的四种核心方案
Java 提供了多种创建线程的方式,从基础的继承类到现代化的线程池技术,适用于不同场景 。
方案对比与代码实现
| 方案 | 特点 | 适用场景 | 代码示例 |
|---|---|---|---|
| 继承 Thread 类 | 简单直接,但受限于单继承 | 简单任务,无需共享资源 | 见下方代码块 1 |
| 实现 Runnable 接口 | 避免单继承局限,资源可共享 | 多任务共享同一资源 | 见下方代码块 2 |
| 实现 Callable 接口 | 支持返回值,可抛出异常 | 需要获取执行结果的异步任务 | 见下方代码块 3 |
| 线程池 (Executor) | 复用线程,控制并发数,降低消耗 | 生产环境高并发场景 | 见下方代码块 4 |
代码示例:基础创建方式
import java.util.concurrent.*;
// 方案 1: 继承 Thread 类
class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread 继承方式执行:" + Thread.currentThread().getName());
}
}
// 方案 2: 实现 Runnable 接口 (推荐,解耦)
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Runnable 实现方式执行:" + Thread.currentThread().getName());
}
}
// 方案 3: 实现 Callable 接口 (带返回值)
class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
return "Callable 执行结果:" + Thread.currentThread().getName();
}
}
public class ThreadCreationDemo {
public static void main(String[] args) throws Exception {
// 启动继承方式
new MyThread().start();
// 启动 Runnable 方式
new Thread(new MyRunnable()).start();
// 启动 Callable 方式 (需配合 FutureTask 或线程池)
FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
new Thread(futureTask).start();
System.out.println("获取返回值:" + futureTask.get()); // 阻塞获取结果
}
}
代码示例:线程池标准化使用
import java.util.concurrent.*;
public class ThreadPoolDemo {
public static void main(String[] args) {
// 创建固定大小线程池 (核心参数:核心线程数,最大线程数,存活时间,单位,队列,工厂,拒绝策略)
ExecutorService executor = new ThreadPoolExecutor(
2, // corePoolSize: 核心线程数
4, // maximumPoolSize: 最大线程数
60L, // keepAliveTime: 非核心线程空闲存活时间
TimeUnit.SECONDS, // unit: 时间单位
new ArrayBlockingQueue<>(10), // workQueue: 任务队列
Executors.defaultThreadFactory(), // threadFactory: 线程工厂
new ThreadPoolExecutor.AbortPolicy() // handler: 拒绝策略 (抛异常)
);
// 提交任务
for (int i = 0; i < 5; i++) {
int taskId = i;
executor.submit(() -> {
System.out.println("线程池处理任务:" + taskId + ", 线程名:" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
// 关闭线程池 (防止资源泄露)
executor.shutdown();
}
}
3. 线程安全与同步机制
多线程环境下,共享资源的访问必须保证原子性、可见性和有序性,否则会导致数据不一致或死锁 。
同步手段对比
| 机制 | 关键字/类 | 特点 | 锁释放规则 |
|---|---|---|---|
| ** synchronized** | 关键字 | 隐式锁,JVM 层面实现,自动加锁解锁 | 执行完代码块或发生异常时自动释放 |
| ** ReentrantLock** | Lock 接口 | 显式锁,API 层面,支持公平锁、可中断、多条件变量 | 必须在 finally 块中手动调用 unlock() |
| ** volatile** | 关键字 | 保证可见性和禁止指令重排,不保证原子性 | 无锁概念,用于标记变量 |
代码示例:Synchronized 与 Lock 的实战
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Counter {
private int count = 0;
private final Lock lock = new ReentrantLock();
// 方式 1: synchronized 修饰方法 (锁住当前对象 this) public synchronized void syncIncrement() {
count++;
// 此处自动加锁,退出方法或异常时自动释放
}
// 方式 2: ReentrantLock 显式锁 (更灵活,支持尝试获取锁等)
public void lockIncrement() {
lock.lock(); // 手动加锁
try {
count++;
} finally {
lock.unlock(); // 必须在 finally 中释放,防止死锁 }
}
public int getCount() {
return count;
}
}
经典问题:死锁与生产者消费者模型
死锁通常发生在两个或多个线程互相持有对方需要的锁并无限等待时 。解决死锁需避免嵌套锁或规定锁的获取顺序。生产者消费者模型则是通过阻塞队列或 wait/notify 机制解决线程间通信的经典案例 。
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ProducerConsumerDemo {
// 使用阻塞队列自动处理等待和通知,避免手动 wait/notify 的复杂性
private static final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);
static class Producer implements Runnable {
@Override
public void run() {
try {
for (int i = 0; i < 20; i++) {
queue.put(i); // 队列满时自动阻塞 System.out.println("生产了:" + i);
Thread.sleep(500);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class Consumer implements Runnable {
@Override
public void run() {
try {
while (true) {
Integer val = queue.take(); // 队列空时自动阻塞
System.out.println("消费了:" + val);
if (val == 19) break; }
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
new Thread(new Producer()).start();
new Thread(new Consumer()).start();
}
}
4. 高级并发工具 (JUC)
除了基础同步,Java 并发包 (java.util.concurrent) 提供了强大的工具类,如 AQS (AbstractQueuedSynchronizer) 是许多锁和同步器的基础框架 。
- CountDownLatch: 允许一个或多个线程等待其他一组线程完成操作 。
- CyclicBarrier: 让一组线程到达一个屏障时被阻塞,直到最后一个线程到达屏障时,所有线程才继续执行。
- Semaphore: 控制同时访问特定资源的线程数量。
import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
int threadCount = 3;
// 初始化计数器,设定为线程数量
CountDownLatch latch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " 开始执行");
try {
Thread.sleep(1000); // 模拟业务耗时
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 执行完毕");
latch.countDown(); // 计数减 1
}).start();
}
// 主线程等待所有子线程执行完毕
latch.await();
System.out.println("所有子任务完成,主线程继续执行");
}
}
5. 面试与优化重点
在求职和技术进阶中,多线程是高频考点,重点关注线程池参数配置原理、AQS 底层实现、CAS 乐观锁机制以及如何在高并发下避免上下文切换过多导致的性能下降 。实际开发中应优先使用线程池而非手动创建线程,并合理选择锁粒度以平衡安全性与性能 。
参考来源
本文系统梳理Java多线程核心内容,涵盖线程生命周期状态、四种线程创建方式对比、线程安全三要素(原子性/可见性/有序性)、synchronized与Lock同步机制、死锁成因与生产者消费者模型、JUC并发工具(CountDownLatch/CyclicBarrier/Semaphore/AQS)及线程池优化要点,强调CAS、锁粒度与上下文切换等高并发关键问题。
3593

被折叠的 条评论
为什么被折叠?



