JAVA EE:4.多线程核心组件实战

【目标】

  1. 掌握单例模式 :能手写线程安全的 DCL 单例,深刻理解 volatile 解决指令重排的必要性。

  2. 掌握阻塞队列:理解生产者-消费者模型,能利用队列实现系统解耦与"削峰填谷"。

  3. 掌握定时器 :理解延迟与周期任务的调度机制,能使用 ScheduledThreadPoolExecutor 处理定时业务。

  4. 掌握线程池 :吃透 ThreadPoolExecutor 的七大核心参数与四大拒绝策略,能根据业务场景(如核心交易、日志后台)进行合理配置与调优。

1.单例模式

在企业级开发中(比如 JDBC 的 DataSource 就是单例的),有些资源非常昂贵,比如数据库连接池 、配置信息管理器 。如果每次用都去 new 一个,内存会直接爆炸,系统也会崩掉。

单例模式的核心诉求只有两个:

  1. 全局唯一:这个类在 JVM 里,永远只能有一个对象。

  2. 全局访问:必须提供一个统一的入口,让所有地方都能拿到这个唯一的对象。

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)。底层三步为:

  1. 分配内存(在堆里开辟空间)
  2. 初始化对象(调用构造方法,给属性赋初始值)
  3. 赋值引用 (把 instance 指向这块内存)

解决的问题 :底层 CPU 为了优化,会把动作拆解并打乱顺序(比如 new 对象的 1-2-3 步打乱为 1-3-2 )。

它的作用:强制在底层插入内存屏障,保证操作严格按照"理想顺序"执行。并且强制刷新主内存,让其他线程立刻看到最新值。

二、synchronized(){}解决本层重排序

而synchronized(){}的存在就很好的解决了这个问题。

synchronized 的核心职责(管宏观)

修饰对象:方法或代码块。

解决的问题:多线程同时执行共享资源(临界区)时,引发的线程安全和数据覆盖问题。

它的三大作用:

  1. 边界防重排(绝对隔离):synchronized 底层自带的 monitorenter 和 monitorexit 指令会形成内存屏障。它保证锁外部的代码绝对不能被重排进锁内,锁内部的代码也绝对不能"偷跑"到锁外。(保证了锁内外的宏观绝对有序)。
  2. 互斥保原子(并发控制):只要有一个线程拿到了锁,其他线程全得在门外乖乖排队。这就保证了锁内部的代码作为一个不可分割的整体执行,不会出现并发交叉执行。(保证了原子性)。
  3. 微观放行(不干预底层指令):它只负责"守大门",不管"屋里人怎么走"。只要进了锁的内部,对于没有数据依赖的代码(比如 int a = 1; int b = 2;),JVM 依然允许 CPU 进行指令重排优化。

2.阻塞队列

2.1 阻塞队列是什么?

阻塞队列(BlockingQueue) 本质上是一种特殊的队列,它同样遵守"先进先出(FIFO)"的原则。

但它是一个线程安全的数据结构,并且自带了两个极其强大的"阻塞"特性:

  1. 队列满时(生产端阻塞) :当队列容量达到上限,如果还有线程试图往里面放数据,该线程就会被阻塞(挂起),直到有其他线程从队列中取走元素,腾出空间。

  2. 队列空时(消费端阻塞) :当队列里没有数据,如果还有线程试图从里面取数据,该线程也会被阻塞,直到有其他线程往队列里插入了新元素。

这两个特性,完美解决了多线程之间"步调不一致"的问题。

2.2 生产者消费者模型是什么?

阻塞队列最典型的应用场景,就是实现**"生产者-消费者模型"**。这是一个非常经典的开发模型,在这个模型中,有两类线程:

  • 生产者(Producer) :负责不断地生成数据或任务,丢进阻塞队列里。

  • 消费者(Consumer) :负责不断地从阻塞队列里取出数据或任务去处理。

2.3 阻塞队列的意义

2.3.1 案例分析

对于 12306 来讲。假设放票瞬间,有 10 万个用户同时点击"查询余票",你的系统会经历什么?

场景一:没有阻塞队列

如果系统没有阻塞队列,这 10 万个请求会直接打到后端的数据库。

  1. 瞬间产生 10 万个数据库**(生产者)** 连接请求,数据库连接池**(消费者)**瞬间被抽干

  2. 数据库 CPU 直接飙升到 100%,甚至直接卡死宕机。

  3. 用户体验:大家全在网页前疯狂转圈圈,最后系统崩溃,白屏报错。

  4. 结果:整个系统彻底雪崩,谁也别想买到票。

场景二:有阻塞队列

如果我们在前端和数据库之间,加一个阻塞队列(BlockingQueue):

  1. 10 万个请求**(生产者)**瞬间涌入,它们不会直接去查数据库,而是被以极快的速度塞进"阻塞队列"里排队

  2. 后端只有少量的"消费者线程"(消费者)(比如 50 个线程)在从队列里拿任务。不管外面来了 10 万人还是 100 万人,数据库永远只承受这 50 个线程的并发压力,稳稳当当

  3. 用户体验:前面的用户很快查到了票;排在后面的用户,页面会显示"排队中,请稍候",而不是直接崩溃白屏。

  4. 结果:系统活着,数据库活着,成功扛住了这波洪水。

这就是阻塞队列最核心的商业价值:用一点等待时间(排队),换取了整个系统的绝对高可用。

2.3.2 阻塞队列的核心作用(理解即可)

1. 核心作用一:解耦

一、 怎么理解解耦(Decoupling)

在系统架构中,"耦合" 指的是系统的各个组件、模块或服务之间存在着强烈的直接依赖关系。 一个组件的变动或异常,会直接导致另一个组件无法正常工作。

而**"解耦"** ,就是通过引入中间层(如阻塞队列、消息队列),切断这种直接依赖,让上下游模块互不感知,各自独立运行。

二、 "解耦"的核心技术意义:

  1. 消除速度依赖(异步化)

    • 在强耦合下,上游(如用户请求)的速度决定了下游(如服务器处理)的速度,上游必须死等下游处理完才能返回。

    • 通过队列解耦后,上游只负责将任务放入队列(瞬时完成),下游按照自身的能力异步处理。上下游在执行速度和生命周期上完全独立。

  2. 隔离故障与风险

    • 在强耦合下,下游系统一旦宕机或发生网络延迟,会直接导致上游请求超时、线程阻塞,进而引发级联故障(雪崩效应)。

    • 解耦后,中间件(队列)充当了缓冲池。下游即使短暂故障,也不会立刻阻塞上游;任务会在队列中堆积,等待下游恢复后继续处理。

  3. 屏蔽实现细节与灵活性

    • 上游系统不需要关心下游具体的处理逻辑、接口协议或扩容情况,只需按统一格式将数据投递到队列中。这极大地降低了模块间的通信成本,使得团队可以独立开发、测试和部署。
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 提交任务时,核心逻辑是:

  1. 当前线程数小于 corePoolSize:创建核心线程执行任务。
  2. 核心线程都忙:任务进入 workQueue 排队。
  3. 队列满了:创建非核心线程,直到 maximumPoolSize 。
    1. 为什么要有界??如果队列无界,任务就一直堆积,看起来"没拒绝任务",实际上可能把内存撑爆,最后整个服务 OOM(Out Of Memory 内存溢出)。

    2. 所以有界队列的意义是:

      限制等待任务的数量,让系统在扛不住时明确拒绝,而不是悄悄堆积到崩溃。

  4. 达到最大线程数,队列也满:执行拒绝策略。

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 线程 + 阻塞队列 + 数量控制 + 拒绝策略。

你目前先抓住三件事:

  1. 为什么需要线程池:复用线程、控制并发、缓冲任务、过载保护。

  2. 参数怎么影响行为:核心线程、最大线程、队列、拒绝策略要一起看。

  3. 实际开发怎么用:优先使用 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);

两个致命缺陷:

  1. 单线程串行:Timer 底层只有一个 Worker 线程。如果任务 A 执行了 10 秒,哪怕任务 B 的时间早就到了,也会被活活拖死(延误)。

  2. 异常即死:如果任务 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 手写实现

一、核心设计思路
  1. 任务类(MyTask):数据结构与排序规则
    1. 封装 :内部持有具体的执行任务(Runnable)和绝对时间戳(当前时间 + 延迟时间)。
    2. 排序 :实现 Comparable 接口,按执行时间升序排列,保证时间最早的任务永远排在最前。
  2. 核心容器:PriorityQueue(优先队列/小顶堆)
    1. 使用 PriorityQueue 替代普通的阻塞队列。它能以 O(1) 的复杂度快速获取队首任务,以 O(log⁡n) 的复杂度插入新任务,完美契合定时器的调度需求。
  3. 核心控制:锁(Locker)与唤醒机制
    1. 提效 :只有当新入队的任务成为新队首时,才调用 notify() 唤醒 Worker。避免无效唤醒,极大地降低了线程上下文切换的开销。
    2. 精准 :Worker 在等待时使用 wait(时间差),拒绝死循环忙等(避免 100% 抢占 CPU)。
  4. Worker 线程:死循环、窥视与隔离
    1. 窥视(Peek) :每次只查看队首,时间到了才出队(Poll)。
    2. 睡眠(Wait):时间未到,精确计算差值并休眠。
    3. 隔离(核心细节) :任务执行(run)必须脱离锁的保护范围。出队后立刻释放锁,在锁外执行任务。防止长耗时任务阻塞其他线程提交新任务。
  5. 5. 优雅停机(Shutdown)
    1. 标志位 :使用 volatile boolean 作为停止标志,保证多线程可见性。
    2. 不暴力强杀 :只设置标志位并 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 线程自行退出)。
相关推荐
杨凯凡18 分钟前
IT日报|2026-11-19:Oracle Java 紧急补丁、Optimizely 供应链攻击、GitHub 安全评估升级
java·oracle·github
JasonChen@6661 小时前
2.Tomcat 安装部署与一键自动化脚本实战
java·tomcat
SimonKing2 小时前
零 OCR 依赖!Firecrawl 这个 Rust 库把 Word / PPT / Excel 全变成 Markdown
java·后端·程序员
Rain的Java大神之路2 小时前
别被 ChatGPT 的打字机效果骗了:一字一字蹦,才是 LLM 自回归的命门(附大厂 Java 流式落地)
java·后端·面试
渣渣盟2 小时前
狂命爆肝99天,共52K字的JAVA学习笔记奉上,JAVA从入门到精通一文搞定,一文在手JAVA无忧
java·笔记·学习
星落梦生3 小时前
Maven高级(9)
java·maven
兴趣互联13 小时前
jeecgboot nacos2.3.2 使用pgsql
java
hudd66814 小时前
JavaEE 初阶 - 文件操作和IO
java·开发语言·java-ee
Flynn Liang15 小时前
HikariCP 连接池不是越大越好:I/O 密集型 Java 服务的数据库容量工程
java·数据库·mysql·高并发·连接池·hikaricp·sql 优化