【目标】
-
掌握单例模式 :能手写线程安全的 DCL 单例,深刻理解
volatile解决指令重排的必要性。 -
掌握阻塞队列:理解生产者-消费者模型,能利用队列实现系统解耦与"削峰填谷"。
-
掌握定时器 :理解延迟与周期任务的调度机制,能使用
ScheduledThreadPoolExecutor处理定时业务。 -
掌握线程池 :吃透
ThreadPoolExecutor的七大核心参数与四大拒绝策略,能根据业务场景(如核心交易、日志后台)进行合理配置与调优。
1.单例模式
在企业级开发中(比如 JDBC 的 DataSource 就是单例的),有些资源非常昂贵,比如数据库连接池 、配置信息管理器 。如果每次用都去 new 一个,内存会直接爆炸,系统也会崩掉。
单例模式的核心诉求只有两个:
全局唯一:这个类在 JVM 里,永远只能有一个对象。
全局访问:必须提供一个统一的入口,让所有地方都能拿到这个唯一的对象。
1.1 前情回顾:static分别修饰不同成员
1.1.1 static 修饰的变量(静态变量)
-
类加载时 :JVM 会给它分配内存,并赋默认值(比如
null、0、false)。如果是显式赋值(如= new Eager()或= 10),会在类加载的"初始化"阶段立刻执行。 -
结论:这是类加载时唯一会被直接处理并赋实际值的成员。
1.1.2 static 修饰的代码块(static { ... })
-
类加载时 :这是为了弥补静态变量无法执行复杂逻辑而设计的。JVM 在类加载的最后阶段(初始化阶段),会按顺序把
static {}里的代码执行一遍。 -
结论 :它和静态变量的显式赋值一样,在类加载时就会执行,且只执行一次。
1.1.3 static 修饰的方法(静态方法)
-
类加载时 :JVM 只是把方法的代码当作一张**"图纸"** 存到方法区里,绝对不会去执行方法体
{}里面的任何代码 (包括里面的new操作)。 -
结论:必须等到程序运行期间,被真正调用时才会执行。
1.1.4 唯一的"例外":静态内部类
如果你把一个类定义成了 static(即静态内部类,比如 static class Inner),那么在外部类加载的时候,这个内部类是完全不会被加载的。只有当程序第一次用到这个内部类时,它才会被加载。
| 修饰目标 | 类加载时的状态 | 是否执行具体代码逻辑 | 实际触发(执行)时机 |
|---|---|---|---|
1. 静态变量 static int a = 10; |
✅ 分配内存并赋予默认值(如 0、null) |
✅ 执行 (按代码顺序执行显式赋值,如 = 10 或 = new Eager()) |
类加载的初始化阶段(且仅执行一次) |
2. 静态代码块 static { ... } |
✅ 被识别并准备执行 | ✅ 执行(按顺序执行块内所有复杂逻辑代码) | 类加载的初始化阶段(且仅执行一次,常用于加载配置) |
3. 静态方法 static void method() {} |
❌ 仅将代码作为"图纸"存入方法区 | ❌ 绝对不执行(方法体内部的代码保持"待命"状态) | 程序运行期间被显式调用时(可以执行无数次) |
4. 静态内部类 static class Inner {} |
❌ 外部类加载时,它完全不加载 | ❌ 不执行 | 程序第一次使用该内部类时,才触发它自身的类加载(延迟加载特性) |
1.2 饿汉模式
java
class Eager {
//饿汉模式,类加载的时候就创建对象
private static Eager instance = new Eager();
private Eager() {}
public static Eager getInstance() {
//获取实例引用
return instance;
}
}
public class Demo14 {
public static void main(String[] args) {
Eager instance = Eager.getInstance();
System.out.println(singleton);
}
}
Eager部分讲解:
1.private static Eager instance = new Eager();
static(静态):代表这个变量属于类本身,在内存的方法区(或元空间)里只有一份,所有实例共享。这是实现"单例"的基础。
private(私有) :不让外人直接改这个变量(防止别人写Eager.instance = null;把单例搞坏)。
= new Eager():这就是"饿"的体现。JVM 在加载这个类的时候,会立刻执行这行代码,把对象造出来放到内存里。2.
private Eager() {}
私有构造器 :这是守护单例的最核心闸门。如果这里是
public,外面直接new Eager(),那单例就破功了。为什么里面是空的?:在简单的业务里,这个对象不需要复杂的初始化(比如读配置文件、连数据库),所以留空。
3.public static Eager getInstance()
这是整个类对外的"唯一窗口"。
别人想要对象,没法
new,只能乖乖调这个静态方法。这个方法无情地把早已造好的instance扔给对方。无论调 1 万次还是 100 万次,拿到的都是同一个地址。
虽然说饿汉模式是线程安全的,但是饿汉模式有一个很大的缺陷:
因为它是**"类加载即初始化"** 。试想,如果你这个单例类在初始化时,需要去读取 10MB 的本地配置文件,或者建立几百个网络连接,那会导致系统启动极慢。而且如果这个类后来根本没用上,这些资源就白白浪费了。
为了解决"饿汉"的问题,我们就想要一个**"不到万不得已不干活"**的模式。这就引出了懒汉模式。
1.3 懒汉模式
1.3.1 不完美
java
class Lazy {
//懒汉模式,类加载的时候不创建对象
private static Lazy instance = null;
private Lazy() {}
public static Lazy getInstance() {
//在真正获取实例对象的时候再进行创建
if (instance == null) {
instance = new Lazy();
}
return instance;
}
}
public class Demo15 {
public static void main(String[] args) {
Lazy instance = Lazy.getInstance();
System.out.println(instance);
}
}
对于上述代码,大家觉得有没有什么问题???

这就又因为调度问题造成了线程不安全问题,所以这里可以进行加锁。
1.3.2 不完美(8.3.1改进)
java
class Lazy {
//懒汉模式,类加载的时候不创建对象
private static Lazy instance = null;
private Lazy() {}
public static Lazy getInstance() {
//在真正获取实例对象的时候再进行创建
synchronized (Lazy.class) {
if (instance == null) {
instance = new Lazy();
}
}
return instance;
}
}
public class Demo15 {
public static void main(String[] args) {
Lazy instance = Lazy.getInstance();
System.out.println(instance);
}
}
这样就可以避免上述情况,但是大家思考:这样做有没有什么缺陷???

1.3.3 不完美(8.3.2改进)
java
class Lazy {
//懒汉模式,类加载的时候不创建对象
private static Lazy instance = null;
private Lazy() {}
public static Lazy getInstance() {
//在真正获取实例对象的时候再进行创建
if (instance == null) {
synchronized (Lazy.class) {
if (instance == null) {
instance = new Lazy();
}
}
}
return instance;
}
}
public class Demo15 {
public static void main(String[] args) {
Lazy instance = Lazy.getInstance();
System.out.println(instance);
}
}
这样就能够大幅度减少重复抢锁的情况(由于并发情况,没办法彻底避免抢锁)
1.3.4 完美------解决两种重排序
由于内存优化,可能会进行重排序等,那么就导致了如下情况:
一、volatile解决底层重排序

所以我们进行更进,加上volatile。
java
class Lazy {
//懒汉模式,类加载的时候不创建对象
private static volatile Lazy instance = null;
private Lazy() {}
public static Lazy getInstance() {
//在真正获取实例对象的时候再进行创建
if (instance == null) {
synchronized (Lazy.class) {
if (instance == null) {
instance = new Lazy();
}
}
}
return instance;
}
}
public class Demo15 {
public static void main(String[] args) {
Lazy instance = Lazy.getInstance();
System.out.println(instance);
}
}
volatile的核心职责(管微观)修饰对象 :类的成员变量(静态、实例皆可),不论它是对象引用(
instance = new Lazy())还是基本类型赋值(a = 1)。底层三步为:
- 分配内存(在堆里开辟空间)
- 初始化对象(调用构造方法,给属性赋初始值)
- 赋值引用 (把
instance指向这块内存)解决的问题 :底层 CPU 为了优化,会把动作拆解并打乱顺序(比如
new对象的 1-2-3 步打乱为 1-3-2 )。它的作用:强制在底层插入内存屏障,保证操作严格按照"理想顺序"执行。并且强制刷新主内存,让其他线程立刻看到最新值。
二、synchronized(){}解决本层重排序

而synchronized(){}的存在就很好的解决了这个问题。
synchronized 的核心职责(管宏观)
修饰对象:方法或代码块。
解决的问题:多线程同时执行共享资源(临界区)时,引发的线程安全和数据覆盖问题。
它的三大作用:
- 边界防重排(绝对隔离):synchronized 底层自带的 monitorenter 和 monitorexit 指令会形成内存屏障。它保证锁外部的代码绝对不能被重排进锁内,锁内部的代码也绝对不能"偷跑"到锁外。(保证了锁内外的宏观绝对有序)。
- 互斥保原子(并发控制):只要有一个线程拿到了锁,其他线程全得在门外乖乖排队。这就保证了锁内部的代码作为一个不可分割的整体执行,不会出现并发交叉执行。(保证了原子性)。
- 微观放行(不干预底层指令):它只负责"守大门",不管"屋里人怎么走"。只要进了锁的内部,对于没有数据依赖的代码(比如 int a = 1; int b = 2;),JVM 依然允许 CPU 进行指令重排优化。
2.阻塞队列
2.1 阻塞队列是什么?
阻塞队列(BlockingQueue) 本质上是一种特殊的队列,它同样遵守"先进先出(FIFO)"的原则。
但它是一个线程安全的数据结构,并且自带了两个极其强大的"阻塞"特性:
队列满时(生产端阻塞) :当队列容量达到上限,如果还有线程试图往里面放数据,该线程就会被阻塞(挂起),直到有其他线程从队列中取走元素,腾出空间。
队列空时(消费端阻塞) :当队列里没有数据,如果还有线程试图从里面取数据,该线程也会被阻塞,直到有其他线程往队列里插入了新元素。
这两个特性,完美解决了多线程之间"步调不一致"的问题。
2.2 生产者消费者模型是什么?
阻塞队列最典型的应用场景,就是实现**"生产者-消费者模型"**。这是一个非常经典的开发模型,在这个模型中,有两类线程:
生产者(Producer) :负责不断地生成数据或任务,丢进阻塞队列里。
消费者(Consumer) :负责不断地从阻塞队列里取出数据或任务去处理。
2.3 阻塞队列的意义
2.3.1 案例分析
对于 12306 来讲。假设放票瞬间,有 10 万个用户同时点击"查询余票",你的系统会经历什么?
场景一:没有阻塞队列
如果系统没有阻塞队列,这 10 万个请求会直接打到后端的数据库。
-
瞬间产生 10 万个数据库**(生产者)** 连接请求,数据库连接池**(消费者)**瞬间被抽干
-
数据库 CPU 直接飙升到 100%,甚至直接卡死宕机。
-
用户体验:大家全在网页前疯狂转圈圈,最后系统崩溃,白屏报错。
-
结果:整个系统彻底雪崩,谁也别想买到票。
场景二:有阻塞队列
如果我们在前端和数据库之间,加一个阻塞队列(BlockingQueue):
-
10 万个请求**(生产者)**瞬间涌入,它们不会直接去查数据库,而是被以极快的速度塞进"阻塞队列"里排队
-
后端只有少量的"消费者线程"(消费者)(比如 50 个线程)在从队列里拿任务。不管外面来了 10 万人还是 100 万人,数据库永远只承受这 50 个线程的并发压力,稳稳当当
-
用户体验:前面的用户很快查到了票;排在后面的用户,页面会显示"排队中,请稍候",而不是直接崩溃白屏。
-
结果:系统活着,数据库活着,成功扛住了这波洪水。
这就是阻塞队列最核心的商业价值:用一点等待时间(排队),换取了整个系统的绝对高可用。

2.3.2 阻塞队列的核心作用(理解即可)
1. 核心作用一:解耦
一、 怎么理解解耦(Decoupling)
在系统架构中,"耦合" 指的是系统的各个组件、模块或服务之间存在着强烈的直接依赖关系。 一个组件的变动或异常,会直接导致另一个组件无法正常工作。
而**"解耦"** ,就是通过引入中间层(如阻塞队列、消息队列),切断这种直接依赖,让上下游模块互不感知,各自独立运行。
二、 "解耦"的核心技术意义:
-
消除速度依赖(异步化)
-
在强耦合下,上游(如用户请求)的速度决定了下游(如服务器处理)的速度,上游必须死等下游处理完才能返回。
-
通过队列解耦后,上游只负责将任务放入队列(瞬时完成),下游按照自身的能力异步处理。上下游在执行速度和生命周期上完全独立。
-
-
隔离故障与风险
-
在强耦合下,下游系统一旦宕机或发生网络延迟,会直接导致上游请求超时、线程阻塞,进而引发级联故障(雪崩效应)。
-
解耦后,中间件(队列)充当了缓冲池。下游即使短暂故障,也不会立刻阻塞上游;任务会在队列中堆积,等待下游恢复后继续处理。
-
-
屏蔽实现细节与灵活性
- 上游系统不需要关心下游具体的处理逻辑、接口协议或扩容情况,只需按统一格式将数据投递到队列中。这极大地降低了模块间的通信成本,使得团队可以独立开发、测试和部署。
2. 核心作用二:削峰填谷
一、 如何理解"波峰"与"波谷"?
在系统架构中,"波峰"与"波谷"描述的是**"系统流量(或并发请求数)随时间变化的曲线特征"。**
波峰(流量峰值):在某一极短的时间窗口内,系统接收到的请求量瞬间暴涨,达到或远超系统最大负载能力。其特点是"瞬时、高并发、不可预测"。
波谷(流量低谷或处理基线):指系统处于相对空闲的状态,或者是系统所能承受的安全、稳定的处理速率(即系统的额定吞吐量)。
二、 "削峰填谷"的技术意义是什么?
"削峰填谷"本质上是系统架构中的**"流量控制与缓冲机制"** ,其核心意义在于**"保证系统的高可用性(防止雪崩)"和"资源的合理化利用"**。
削峰(保护后端,防止系统崩溃)
- 动作:在流量到达核心处理节点(如数据库)之前,引入缓冲层(阻塞队列),将瞬时的"波峰"流量拦截并缓存。
- 意义:避免超出系统承载极限的流量直接冲击底层基础设施,防止因资源耗尽(如 CPU 满载、连接池耗尽)导致的系统宕机和数据丢失。
填谷(平滑消费,提升资源利用率)
- 动作:后端处理节点(消费者)不再受前端请求突发的干扰,而是以自身能够承受的恒定速率(基线)从缓冲层中拉取任务进行处理。
- 意义:将原本可能在瞬间闲置、又在另一瞬间过载的系统资源,进行时间维度上的重新分配。使得系统在流量低谷时能充分利用闲置资源消化积压任务,实现负载均衡与资源利用最大化。
3. 最常用的两大实现类
-
ArrayBlockingQueue(有界队列):底层是数组,必须指定大小。一把锁控制读写,适合并发量适中、需要严格防止内存溢出的场景。 -
LinkedBlockingQueue(无界/有界队列) :底层是链表,默认大小是 21 亿(近乎无界)。底层是两把锁(读写分离),并发性能极高。
2.4 阻塞队列的使用
生产者-消费者模型 中,核心诉求是:没货时消费者必须等,满仓时生产者必须等 。所以在这个模型里,只用两个方法:
put(E e) ------ 生产者专用
作用:往队列里放数据。
规矩 :如果队列满了,当前线程直接阻塞(死等),直到消费者拿走数据腾出空间。
take() ------ 消费者专用
作用:从队列里拿数据。
规矩 :如果队列空了,当前线程直接阻塞(死等),直到生产者放入新数据。
java
class Test {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(3);
//底层数组容量为5
Thread thread1 = new Thread(() -> {
//生产者(用户):阻塞队列中,请求大于5就阻塞
for (int i = 1; i <= 100; i++) {
try {
blockingQueue.put(i);
System.out.println("第" + i + "个数据存入成功");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
Thread thread2 = new Thread(() -> {
//消费者(服务器):当阻塞队列中无请求就阻塞
for (int i = 1; i <= 100; i++) {
try {
blockingQueue.take();
System.out.println("第" + i + "个数据取出成功");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("存取完毕");
}
}
部分结果截取:

2.5 阻塞队列的实现
java
public class MyBlockingQueue{
//通过循环数组来实现队列
int[] elem = null;
int size = 0;//size用于表示数组是否满,和循环无关系,所以在代码中不需要执着size的循环关系
int head = 0;//用来取数据用
int tail = 0;//用来存数据用
public MyBlockingQueue(int capacity) {
if(elem == null) {
//指定数组的容量大小,也就是阻塞队列同时最大能放入/取出的量
elem = new int[capacity];
}
}
public void put(int value) throws InterruptedException {
synchronized (this) {
while (size >= elem.length) {
wait();
//满了就阻塞
}
//走到这里表示数组不满,可以放入了
if(tail == elem.length) {
//处于交界线,也就是tail == elem.length
tail = 0;
}
elem[tail++] = value;//先放入,再++
size++;//容量++
notifyAll();//表示可以取了,那么就唤醒其他线程的 取:wait()
}
}
public int take() throws InterruptedException {
synchronized (this) {
while (size == 0) {
wait();
//空了就阻塞
}
//走到这里表示数据不为空,可以取了
int ret = elem[head++];
if(head == elem.length) {
//处于交界线,要指向第一个元素所在的位置
head = 0;
}
size--;//容量--
notifyAll();//表示可以放了,那么就唤醒其他线程的 放:wait()
return ret;
}
}
public static void main(String[] args) throws InterruptedException {
MyBlockingQueue blockingQueue = new MyBlockingQueue(5);
//底层数组容量为5
Thread thread1 = new Thread(() -> {
//生产者(用户):阻塞队列中,请求大于5就阻塞
for (int i = 1; i <= 100; i++) {
try {
blockingQueue.put(i);
System.out.println("数据" + i + "存入成功");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
Thread thread2 = new Thread(() -> {
//消费者(服务器):当阻塞队列中无请求就阻塞
for (int i = 1; i <= 100; i++) {
try {
int ret = blockingQueue.take();
System.out.println("数据" + ret + "取出成功");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("存取完毕");
}
}
3.线程池
3.1 线程池是什么
3.1.1 概念
线程池是一个 "统一管理线程和任务" 的 "容器" 。它通常包含:
- 一组 Worker 线程;
- 一个任务队列;
- 线程数量控制规则;
- 任务拒绝策略;
- 在阻塞队列中,实行的是阻塞操作
- 在线程池中,更多的是真正意义上的"拒绝"
- 线程生命周期管理。
你可以先用"生产者---消费者"理解:
- 提交任务的线程是生产者;
- Worker 线程是消费者;
- BlockingQueue 是中间的缓冲区。
3.1.2 类比
想象一家餐厅:
核心员工:正式员工,平时一直在店里;
临时员工:高峰期客人太多时临时叫来;
候餐区:订单排队的地方;
最大员工数:店里最多能站下多少员工,包括核心员工和临时员工;
拒绝策略:人满了、订单也排满了,新订单怎么办。
3.1.3 为什么要用线程池
- 减少线程创建和销毁的开销:线程是操作系统资源,不是免费的。
- 控制并发量:避免请求一多就无限创建线程,把 CPU、内存、数据库连接打爆。
- 缓冲任务:高峰期先把任务排队,Worker 慢慢处理。
- 提供过载保护:队列满了以后可以拒绝任务,而不是悄悄堆积到内存溢出。
- 统一管理:线程命名、监控、关闭、隔离都更方便。
3.2 线程池的执行流程
ThreadPoolExecutor 提交任务时,核心逻辑是:
- 当前线程数小于 corePoolSize:创建核心线程执行任务。
- 核心线程都忙:任务进入 workQueue 排队。
- 队列满了:创建非核心线程,直到 maximumPoolSize 。
为什么要有界??如果队列无界,任务就一直堆积,看起来"没拒绝任务",实际上可能把内存撑爆,最后整个服务 OOM(Out Of Memory 内存溢出)。
所以有界队列的意义是:
限制等待任务的数量,让系统在扛不住时明确拒绝,而不是悄悄堆积到崩溃。
- 达到最大线程数,队列也满:执行拒绝策略。
3.3 实际开发中怎么创建线程池
3.3.1 实际用法(全面、重要)
java
ThreadPoolExecutor pool = new ThreadPoolExecutor(
4, // int corePoolSize 核心线程数
//平时保留 4 个核心线程,类似正式员工
8, // int maximumPoolSize 最大线程数
//高峰期最多扩到 8 个线程,类似最多再叫 4 个临时工。
/*只有队列满了,线程池才会尝试把线程数从 corePoolSize 扩到 maximumPoolSize。*/
60L, // long keepAliveTime 非核心线程空闲存活时间
TimeUnit.SECONDS, // TimeUnit unit 时间单位
///60L + TimeUnit.SECONDS:临时工空闲 60 秒就辞退,减少资源占用。
new ArrayBlockingQueue<>(100), // BlockingQueue<Runnable> workQueue 有界任务队列
//最多排队 100 个任务,防止无限堆积。
new NamedThreadFactory("order-pool"), // ThreadFactory threadFactory 自定义线程工厂
//给线程起名字,出问题时日志和线程栈更容易排查。
new ThreadPoolExecutor.CallerRunsPolicy() // RejectedExecutionHandler handler 拒绝策略
//线程和队列都满了,让提交任务的线程自己执行,形成一种"反压"。
);
//核心线程数是日常处理能力,最大线程数是峰值处理能力,队列是缓冲,拒绝策略是过载保护。
3.3.2 关于线程工厂:
java
//线程工厂就是:线程池需要新线程时,由它负责"生产"这个线程。
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
public class NamedThreadFactory implements ThreadFactory {
private final AtomicInteger sequence = new AtomicInteger(1);
private final String prefix;
public NamedThreadFactory(String prefix) {
this.prefix = prefix;
}
@Override
public Thread newThread(Runnable task) {
// 线程名字会出现在日志、线程栈和监控里。
// 例如 order-pool-1、order-pool-2。
Thread thread = new Thread(task, prefix + "-" + sequence.getAndIncrement());
// 任务里没有被捕获的异常,可以在这里统一记录。
thread.setUncaughtExceptionHandler((t, e) ->
System.err.println("线程 " + t.getName() + " 发生异常: " + e));
return thread;
}
}
3.3.3 构造方法的重载及介绍:
关于其构造方法,有很多种"重载",其中上述是最全面的一种,还有以下几种(包含上述):
| 序号 | 构造方法 | 默认行为 | 常用场景 |
|---|---|---|---|
| 1 | ThreadPoolExecutor( int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) |
默认线程工厂 + 默认 AbortPolicy 拒绝策略 |
简单示例、测试;生产不推荐,因为线程名和拒绝策略都不可控 |
| 2 | ThreadPoolExecutor( int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue ThreadFactory threadFactory) |
自定义线程工厂 + 默认 AbortPolicy |
需要给线程起名,但暂时用默认拒绝策略 |
| 3 | ThreadPoolExecutor( int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler) |
默认线程工厂 + 自定义拒绝策略 | 需要自定义拒绝策略,但不太在意线程名 |
| 4 | ThreadPoolExecutor( int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory, RejectedExecutionHandler handler) |
全部自定义 | 实际开发最常用,线程名、队列、拒绝策略都可控 |
| 参数 | 含义 |
|---|---|
corePoolSize |
核心线程数,平时保留的线程数 |
maximumPoolSize |
最大线程数,包含核心线程 |
keepAliveTime |
非核心线程空闲多久后回收 |
unit |
时间单位,如 TimeUnit.SECONDS |
workQueue |
任务阻塞队列,推荐使用有界队列 |
threadFactory |
线程工厂,负责创建线程、给线程命名 |
handler |
拒绝策略,线程和队列都满时怎么处理 |
在实际开发中,用的最多的是第四个!!!
3.4 常用方法
3.4.1 execute:提交任务,不关心返回值
java
pool.execute(() -> {
System.out.println("异步执行任务");
});
适合发通知、写日志、清理数据这种不需要返回结果的任务。
意义:让调用方不必等待任务完成,提高响应速度。
注意:任务异常不一定能在调用方直接感知,所以业务任务内部最好自己处理异常。
3.4.2 submit:提交任务,返回 Future
java
Future<Integer> future = pool.submit(() -> {
return 1 + 1;
});
// get() 会阻塞等待结果,建议加超时
Integer result = future.get(3, TimeUnit.SECONDS);
意义:可以获取异步任务的执行结果,也可以取消任务。
难点类比:
submit 像你在餐厅点了一份现做的菜,服务员给你一张小票,这张小票就是 `Future`。
你可以过一会儿拿小票去取菜;如果菜一直没好,`get()` 就会让你一直等,所以最好加上超时。
3.4.3 关闭线程池
一、shutdown():优雅关闭
threadPoolExecutor.shutdown();
含义:
-
不再接收新任务;
-
已经提交的任务会继续执行;
-
正在执行的任务不会被中断;
-
队列里还没执行的任务也会继续执行完,然后线程逐渐退出。
executor.shutdown();
if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
executor.shutdownNow();
}
先等 30 秒,任务还没结束再强制关闭。
二、shutdownNow():立即关闭
List<Runnable> pendingTasks = threadPoolExecutor.shutdownNow();
含义:
- 不再接收新任务;
- 尝试中断正在执行的任务;
- 队列中等待的任务不再执行;
- 返回队列里未执行的任务列表。
shutdownNow()只是"尝试中断",不是保证一定停掉。如果任务不响应中断,比如一直死循环、不检查中断标志,它仍然可能继续运行。
3.4.4 其他常用方法
java
pool.getActiveCount(); // 正在执行的线程数
pool.getQueue().size(); // 队列中积压的任务数
pool.getCompletedTaskCount(); // 已完成任务数
监控意义:
如果队列长期积压、活跃线程数长期等于最大值,说明线程池可能扛不住了,需要扩容或限流,而不是继续往里塞任务。
3.5 注意事项
3.5.1 不要用无界队列掩盖问题
无界队列看起来"任务都不会丢",实际上是让任务堆积到 OOM(Out Of Memory)。
生产环境更推荐有界队列,配合拒绝策略和监控。
3.5.2 maximumPoolSize 不是立即生效
只有核心线程忙、队列也满了,才会扩容。
如果你用无界队列,最大线程数可能永远用不到。
3.5.3 线程池要命名
默认线程名通常是 pool-1-thread-1,线上出问题很难定位。
按业务命名,例如 order-pool-1、sms-pool-1,日志和线程栈一眼就能看出是谁。
3.5.4 ThreadLocal 要清理
线程池复用线程,如果任务里用了 ThreadLocal,任务结束后不清理,可能污染下一个任务。
ThreadLocal 可以理解成:每个线程自己的"私有储物柜"。
java
private static final ThreadLocal<String> CURRENT_USER = new ThreadLocal<>();
CURRENT_USER.set("张三"); // 只有当前线程能读到
String user = CURRENT_USER.get();
它不是让多个线程共享数据,而是让每个线程各存一份互不影响的数据 。如果针对单个线程来说,用完就销毁了;但是线程池中的线程是复用 的,切换到下一个任务可能还是同一个线程,这样就读取到了不属于任务本身的数据,这就造成了数据污染。
java
try {
// 业务逻辑
} finally {
threadLocal.remove();
}
3.6 自我实现一个线程池
下面实现一个 简化版固定大小线程池
- Worker 线程;
- BlockingQueue 任务队列;
- 任务提交;
- 任务异常处理;
- 优雅关闭。
java
public final class MiniFixedThreadPool implements AutoCloseable {
/**
* 毒丸任务:专门用来通知 Worker 退出。
* 它不是业务任务,只作为队列中的"关闭信号"。
*/
private static final Runnable POISON = () -> { };
/**
* 所有待执行任务都放在这里。
* 这里为了先理解原理,使用无界队列。
* 生产环境应该改成有界队列,并配合拒绝策略。
*/
private final BlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();
/**
* 保存所有 Worker,关闭时需要使用。
*/
private final List<Thread> workers = new ArrayList<>();
/**
* 保护"提交任务"和"关闭线程池"两个动作,
* 避免关闭之后还有任务被放进来。
*/
private final Object lifecycleLock = new Object();
private volatile boolean shutdown;
public MiniFixedThreadPool(int workerCount, String namePrefix) {
if (workerCount <= 0) {
throw new IllegalArgumentException("workerCount 必须大于 0");
}
for (int i = 0; i < workerCount; i++) {
Thread worker = new Thread(() -> {
while (true) {
Runnable task;
try {
/*
* 关键点 1:队列为空时阻塞等待。
* 就像员工没有订单时在店里等着,
* 不占用 CPU 空转。
*/
task = taskQueue.take();
} catch (InterruptedException e) {
// shutdownNow() 会中断 Worker,这里正常退出。
Thread.currentThread().interrupt();
return;
}
// 关键点 2:收到毒丸,说明该退出了。
if (task == POISON) {
return;
}
try {
// 关键点 3:执行用户任务。
task.run();
} catch (Throwable t) {
/*
* 关键点 4:任务抛异常不能杀死 Worker。
* 如果这里不捕获,一个任务异常就可能让 Worker 退出,
* 线程池的线程会越来越少。
*
* 生产环境不能只 printStackTrace,
* 应该记录日志、上报监控、告警。
*/
t.printStackTrace();
}
}
}, namePrefix + "-worker-" + i);
worker.start();
workers.add(worker);
}
}
//提交任务
public void execute(Runnable task) {
if (task == null) {
throw new NullPointerException("task 不能为 null");
}
synchronized (lifecycleLock) {
if (shutdown) {
throw new RejectedExecutionException("线程池已经关闭");
}
/*
* 关键点 5:任务先进入阻塞队列,
* Worker 再从队列里取任务。
*
* 这就是生产者-消费者模型:
* execute 是生产者,Worker 是消费者。
*/
taskQueue.offer(task);
}
}
//优雅关闭:不再接收新任务,但已经提交的任务继续处理。
public void shutdown() {
synchronized (lifecycleLock) {
if (shutdown) {
return;
}
shutdown = true;
/*
* 关键点 6:给每个 Worker 放入一个毒丸。
*
* 毒丸排在已有任务后面,
* 所以 Worker 会先处理完队列里的业务任务,
* 再取到毒丸并退出。
*/
for (int i = 0; i < workers.size(); i++) {
taskQueue.offer(POISON);
}
}
}
/**
* 立即关闭:清空未执行任务,并中断 Worker。
*/
public List<Runnable> shutdownNow() {
synchronized (lifecycleLock) {
shutdown = true;
List<Runnable> pendingTasks = new ArrayList<>(taskQueue);
taskQueue.clear();
for (Thread worker : workers) {
worker.interrupt();
}
return pendingTasks;
}
}
@Override
public void close() {
shutdown();
}
}
public class Demo {
public static void main(String[] args) throws Exception {
MiniFixedThreadPool pool = new MiniFixedThreadPool(4, "demo-pool");
try {
for (int i = 0; i < 20; i++) {
int taskId = i;
pool.execute(() -> {
System.out.println(
Thread.currentThread().getName()+ " 执行任务 " + taskId
);
});
}
} finally {
pool.shutdown();
}
}
}
3.7 总结
线程池可以记成一句话:
线程池 = Worker 线程 + 阻塞队列 + 数量控制 + 拒绝策略。
你目前先抓住三件事:
-
为什么需要线程池:复用线程、控制并发、缓冲任务、过载保护。
-
参数怎么影响行为:核心线程、最大线程、队列、拒绝策略要一起看。
-
实际开发怎么用:优先使用 ThreadPoolExecutor,不要无脑用 Executors 工厂方法(此处不进行讲解)。
4.定时器
4.1 概念介绍
定时器是软件开发中用于"在指定时间点或指定延迟后触发执行特定代码 "的组件。
以下是关于"定时器"相关名词的解析:
- 相对时间(Delay):比如"延迟 3 秒执行"。
- 绝对时间(Timestamp):比如"在 2026-11-18 21:00:00 执行"。
- 小根堆(Min-Heap):一种特殊的完全二叉树。
- 特点:"父节点的值永远小于或等于子节点"。
- 在定时器中的作用:把执行时间最早的任务永远放在堆顶(队首),这样系统每次只需要拿当前时间去和堆顶任务比较,时间复杂度O(1),极其高效。
- 忙等(Busy Waiting):线程为了等待条件成立,在一个死循环里疯狂检查,不释放 CPU。
- 危害:如果定时器用 while(true) 疯狂扫描时间,会导致 CPU 占用率飙升 100%,风扇狂转,极其浪费资源。必须用 wait(时间差) 让线程休眠。
- 精准唤醒:当 Worker 线程准备休眠 10 秒时,如果突然来了个 2 秒后执行的新任务,必须强行打断 Worker 的休眠,让它重新看一眼堆顶,重新计算休眠时间。
4.2 实际常用方法
4.2.1 Timer类的缺陷
java
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() { System.out.println("执行任务"); }
}, 3000);
两个致命缺陷:
单线程串行:Timer 底层只有一个 Worker 线程。如果任务 A 执行了 10 秒,哪怕任务 B 的时间早就到了,也会被活活拖死(延误)。
异常即死:如果任务 A 抛出了未捕获的 RuntimeException,**整个 Timer 线程会瞬间崩溃!!**后面所有排队的定时任务全部彻底停摆,直接线上事故。
4.2.2 ScheduledThreadPoolExecutor类的优点
ScheduledThreadPoolExecutor的名字虽然长,但拆开看就懂了:
Scheduled:调度的(定时)
ThreadPool:线程池
Executor:执行器
连起来就是:一个支持定时和周期任务的线程池。
java
// 1. 创建包含 2 个核心线程的定时器线程池
ScheduledExecutorService executor = new ScheduledThreadPoolExecutor(2);
// 左边 ScheduledExecutorService:是 JDK 提供的接口。
// 右边 ScheduledThreadPoolExecutor:是真正的实现类,也是用来彻底替代 Timer 的核心组件。
// 参数 2:核心线程数。最好不要设 1!如果只有 1 个线程,遇到耗时任务就会堵塞后续所有任务(这就是 Timer 的缺陷)。设为 2及以上 意味着可以并行处理。
// 2.提供的方法(以下,lambda重写的是 Runnable 的 run() 方法)
// 2.1 延迟 3 秒执行一次
executor.schedule(
() -> System.out.println("任务1"),
3,
TimeUnit.SECONDS);
// schedule方法:代表"一次性定时"。只执行一次就结束,不会循环。
// 参数1 () -> ...:Lambda 表达式,代表具体的业务代码。
// 参数2 3:延迟的时间数值。
// 参数3 TimeUnit.SECONDS:时间单位,需要导包。
// 2.2 首次延迟 1 秒,之后每 2 秒执行一次(固定延迟)
executor.scheduleWithFixedDelay(
() -> System.out.println("任务2"),
1,
2,
TimeUnit.SECONDS);
// scheduleWithFixedDelay方法:周期性任务,循环任务用它。
// 参数2 1:initialDelay,首次延迟。程序刚启动不立刻执行,先等 1 秒执行第一次。
// 参数3 2:delay,周期间隔。这个 2 秒是从"上一次任务执行完毕"开始算的。上一次彻底结束,再等 2 秒,才执行下一次。
// 2.3 首次延迟 0 秒,之后每隔 2 秒执行一次(固定频率)
executor.scheduleAtFixedRate(
() -> { System.out.println("Task executed"); },
0,
2,
TimeUnit.SECONDS
);
//避坑:千万别用 scheduleAtFixedRate方法(固定频率),它是从任务"开始执行"算时间。
//第0秒:对于任务A,到了其执行时间,把他放到线程池中。线程一执行、执行需要5秒
//第2秒:对于任务B,到了其执行时间,把他放到线程池中。线程二执行、执行需要5秒
//第4秒:对于任务C,到了其执行时间,把他放到线程池中。任务A、B未结束,阻塞等待
//第5秒:对于任务A,任务结束,任务C上。
//......
//上述拿2个线程进行演示。但是任务千千万,我们通过增加线程池中线程个数的方式,解决不了这样的问题。如果使用这样的方法,会导致任务疯狂并发堆积,直接 OOM(Out Of Memory,内存溢出)
//3.关闭定时器
executor.shutdown();
4.2.3 手写实现
一、核心设计思路
- 任务类(MyTask):数据结构与排序规则
- 封装 :内部持有具体的执行任务(
Runnable)和绝对时间戳(当前时间 + 延迟时间)。- 排序 :实现
Comparable接口,按执行时间升序排列,保证时间最早的任务永远排在最前。- 核心容器:PriorityQueue(优先队列/小顶堆)
- 使用
PriorityQueue替代普通的阻塞队列。它能以 O(1) 的复杂度快速获取队首任务,以 O(logn) 的复杂度插入新任务,完美契合定时器的调度需求。- 核心控制:锁(Locker)与唤醒机制
- 提效 :只有当新入队的任务成为新队首时,才调用
notify()唤醒 Worker。避免无效唤醒,极大地降低了线程上下文切换的开销。- 精准 :Worker 在等待时使用
wait(时间差),拒绝死循环忙等(避免 100% 抢占 CPU)。- Worker 线程:死循环、窥视与隔离
- 窥视(Peek) :每次只查看队首,时间到了才出队(
Poll)。- 睡眠(Wait):时间未到,精确计算差值并休眠。
- 隔离(核心细节) :任务执行(run)必须脱离锁的保护范围。出队后立刻释放锁,在锁外执行任务。防止长耗时任务阻塞其他线程提交新任务。
- 5. 优雅停机(Shutdown)
- 标志位 :使用
volatile boolean作为停止标志,保证多线程可见性。- 不暴力强杀 :只设置标志位并
notifyAll()唤醒沉睡的 Worker,让它自己检测标志位并结束循环,坚决不调用interrupt()强杀,确保正在执行的任务能善终。
二、 细节代码拆解
第一阶段:任务的诞生与排队
java
//触发动作:主线程调用了 schedule(...) 方法。
// 1. 提交任务入口
public void schedule(Runnable runnable, long delay) {
// 步骤 1.1:加锁,保证多线程同时提交任务时,队列安全
synchronized (locker) {
// 步骤 1.2:将任务封装,并计算出"绝对执行时间"
MyTask task = new MyTask(runnable, delay);
// 步骤 1.3:扔进小顶堆(优先队列),底层会自动按时间排序
queue.offer(task);
// 步骤 1.4:如果新来的任务排在了队首(说明它是目前最早要执行的)
if (queue.peek() == task) {
locker.notify(); // 唤醒正在睡觉的 Worker,告诉它"有新活,而且很急!"
}
}
}
第二阶段:调度、判断与休眠
java
//触发动作:后台的 Worker 线程在 while(!stopped) 死循环里不断运转。
// 2. 构造方法中启动 Worker 线程
public MyScheduledThreadPoolExecutor() {
worker = new Thread(() -> {
try {
while (!stopped) {
MyTask task = null;
// 步骤 2.1:加锁,准备操作队列
synchronized (locker) {
// 步骤 2.2:如果队列为空,且没说要停机,就释放锁去睡觉
while (!stopped && queue.isEmpty()) {
locker.wait();
}
// 步骤 2.3:醒来后第一件事,检查是不是要停机了
if (stopped) {
return; // 结束死循环,Worker 退休
}
// 步骤 2.4:看一眼队首(只拿引用,不出队)
MyTask headTask = queue.peek();
long now = System.currentTimeMillis(); // 获取当前时间
// 步骤 2.5:时间到没到?
if (now >= headTask.time) {
// 分支 A:时间到了,赶紧出队!
task = queue.poll();
} else {
// 分支 B:时间没到,计算还差多少毫秒
// 精确休眠(这期间如果来了更早的新任务,会被 notify 打断)
locker.wait(headTask.time - now);
}
} // ★ 核心细节:出了大括号,锁就释放了!
// 步骤 2.6:在【锁外面】执行任务
if (task != null) {
try {
// 真正干活!防止阻塞期间其他人不能提交任务
task.runnable.run();
} catch (Exception e) {
// 兜底异常,防止 Worker 线程直接死掉
System.out.println("任务执行异常:" + e.getMessage());
}
}
}
} catch (InterruptedException e) {
System.out.println("Worker 线程被中断,即将退出");
}
});
worker.setDaemon(true); // 设置为守护线程(主线程如果结束,它也就结束了)
worker.start(); // 启动 Worker
}
第三阶段:停机
java
//触发动作:主线程调用了 shutdown()。
// 3. 停机入口
public void shutdown() {
// 步骤 3.1:设置停止标志位(volatile 保证 Worker 线程能立刻看到)
stopped = true;
// 步骤 3.2:叫醒可能还在 wait() 睡觉的 Worker
synchronized (locker) {
locker.notifyAll();
}
// 注意:这里没有使用 worker.interrupt()。
// 如果 Worker 正在执行任务,强杀会导致数据不一致。
// Worker 被叫醒后,走到步骤 2.3 发现 stopped == true,就会自己安全退出。
}
java
//核心组件:MyTask 任务类(数据结构)
static class MyTask implements Comparable<MyTask> {
Runnable runnable;
long time; // 核心:存绝对时间戳
public MyTask(Runnable runnable, long delay) {
this.runnable = runnable;
// 对应步骤 1.2:当前时间 + 延迟时间
this.time = System.currentTimeMillis() + delay;
}
@Override
public int compareTo(MyTask o) {
// 对应步骤 1.3:小顶堆的排序规则(时间越小,越排前面)
return Long.compare(this.time, o.time);
}
}
三、总的完整代码
java
import java.util.PriorityQueue;
public class MyScheduledThreadPoolExecutor {
private final PriorityQueue<MyTask> queue = new PriorityQueue<>();
private final Object locker = new Object();
private Thread worker = null;
private volatile boolean stopped = false; // 停止标志
static class MyTask implements Comparable<MyTask> {
Runnable runnable;
long time; // 绝对执行时间戳
public MyTask(Runnable runnable, long delay) {
this.runnable = runnable;
this.time = System.currentTimeMillis() + delay;
}
@Override
public int compareTo(MyTask o) {
return Long.compare(this.time, o.time);
}
}
public MyScheduledThreadPoolExecutor() {
worker = new Thread(() -> {
try {
while (!stopped) {
MyTask task = null;
synchronized (locker) {
// 1. 如果队列为空且没停止,就死等
while (!stopped && queue.isEmpty()) {
locker.wait();
}
// 2. 醒来发现要停机了,直接结束
if (stopped) {
return;
}
// 3. 看一眼队首
MyTask headTask = queue.peek();
long now = System.currentTimeMillis();
if (now >= headTask.time) {
// 4. 时间到了,出队
task = queue.poll();
} else {
// 5. 时间没到,计算差值,精确休眠
locker.wait(headTask.time - now);
}
} // 出了 synchronized 块,锁就释放了!其他线程可以随时提交新任务。
// 6. 在锁外面执行任务(防止任务耗时过长阻塞队列)
if (task != null) {
try {
task.runnable.run();
} catch (Exception e) {
System.out.println("任务执行异常:" + e.getMessage());
}
}
}
} catch (InterruptedException e) {
System.out.println("Worker 线程被中断,即将退出");
}
});
worker.setDaemon(true); // 守护线程,随主线程退出而退出
worker.start();
}
public void schedule(Runnable runnable, long delay) {
synchronized (locker) {
MyTask task = new MyTask(runnable, delay);
queue.offer(task);
// 只有当新任务排在了队首(即它是目前最早要执行的任务)时,才唤醒 Worker。
// 如果新任务排在后面,没必要唤醒,Worker 该睡多久睡多久。
if (queue.peek() == task) {
locker.notify();
}
}
}
// 停机
public void shutdown() {
stopped = true; // 1. 设置停止标志
synchronized (locker) {
locker.notifyAll(); // 2. 叫醒可能正在 wait() 的 Worker,让它赶紧看一眼 stopped 标志
}
// 不调用 worker.interrupt()。因为 worker 可能正在执行任务,
// 强行 interrupt 会导致业务逻辑被当场掐断,数据可能不一致。
// 让 Worker 自己发现 stopped=true 后,在循环头自然结束。
}
}
四、为啥不直接用PriorityBlockingQueue来做容器
核心原因是: 它阻塞的条件,不是定时器需要的条件。
java
//1.PriorityBlockingQueue.take() 的逻辑可以简化成:
//它只关心: 队列里有没有元素。
while (队列是空的) {
等待;
}
return 取出队首元素;
//2.但定时器需要的是:
if (队列是空的) {
无限等待新任务;
} else if (队首任务还没到期) {
等待"距离到期的剩余时间";
} else {
取出任务并执行;
}
4.3 核心避坑细节
4.3.1 构造函数里的 poolSize 就是并发度
java
// 构造函数参数直接决定核心线程数
new ScheduledThreadPoolExecutor(4);
**new ScheduledThreadPoolExecutor(1)**意味着所有定时任务串行执行,一个慢任务会阻塞后面所有任务。
4.3.2 周期任务必须自己 try-catch
任务抛出异常后,JVM 不会把异常打印到日志
java
executor.scheduleWithFixedDelay(() -> {
try {
//......
} catch (Throwable t) {
//......
}
}, 0, 5, TimeUnit.SECONDS);
4.3.3 优先选用 scheduleWithFixedDelay
scheduleAtFixedRate:下一轮执行时间以 上次计划时刻 + period 为基准计算。任务耗时超过 period 时,会 连续执行(实际周期等于任务耗时),没有空闲。
scheduleWithFixedDelay :以上次执行结束时刻 + delay 为基准计算。绝大多数业务应选这个。
4.3.4 必须在任务体外部包裹业务判断(防时钟回拨)
java
// 如果服务器时间被 NTP 校准往回拨,定时任务可能永远无法触发
if (System.currentTimeMillis() < lastExecutionTime) {
// 记录警告,重置时间基准
}
-
避坑 :底层如果用
System.currentTimeMillis()计算绝对时间,一旦运维进行 NTP 时间同步(时钟回拨),定时器可能直接"沉睡"或者疯狂触发。 -
最佳实践 :大厂高精度中间件在底层计算时间差时,通常采用
System.nanoTime()(相对时间)来避免受系统时钟修改的干扰。
1. 什么是时钟回拨(Clock Drift)?
这个最常见,完全是人为或系统校准造成的。
场景:服务器开机久了,主板上的晶振会有微小误差(比如每天慢 1 秒)。运维为了精准,会配置 NTP(网络时间协议)服务定期去互联网上对时。
灾难 :假设你的服务器现在是 10:00:05,NTP 服务器告诉它:"你快了 5 秒,真实时间是 10:00:00"。于是,系统时间瞬间倒退回了 10:00:00。
对定时器的影响 :你原本用
currentTimeMillis()算好了一个任务 3 秒后执行。结果时间倒退了 5 秒,这个任务相当于要等 8 秒才能执行,甚至可能因为计算时间差出现负数而陷入死循环。2. 什么是闰秒(Leap Second)?
这个极其罕见,是地球自转 造成的物理现象。
地球自转越来越慢,为了让人造的系统时间(UTC)和地球实际昼夜(天文时间)保持同步,国际组织偶尔会在某一天的 23:59:59 后面,硬生生加上一秒钟,变成 23:59:60。
对系统的影响:很多操作系统(比如早期的 Linux)在遇到"23:59:60"时,内核会直接懵圈,导致瞬间 CPU 飙升、系统卡死。
它的本质 :它不是时间倒退,而是时间被"强塞"了一秒,导致现实时间线上出现了折叠或重复。
4.3.5 定时器资源必须优雅关闭(防内存泄漏)
java
// 服务停机或组件销毁时
executor.shutdown();
避坑 :如果不调用
shutdown(),核心线程会一直活着(哪怕主方法结束,进程也退不出来)。最佳实践 :在
finally块或 Spring 的@PreDestroy中调用shutdown()。它不会强杀正在执行的任务,而是拒绝新任务,等现有任务执行完后自然退出。坚决不用shutdownNow()暴力强杀。shutdown() 不阻塞、不等待 。
- 把线程池状态从 RUNNING 置为 SHUTDOWN;
- 之后再提交任务 会被拒绝 ,并抛出 RejectedExecutionException;
- 已经提交的任务 继续执行完 (任务执行完后,worker 线程自行退出)。

