Java多线程详解①①（全程干货！！！） 实现简单的线程池 || 定时器 || 简单实现定时器 || 时间轮实现定时器

这里是Themberfue

· 上一节讲了 线程池 线程池中的拒绝策略 等相关内容 

---

实现简单的线程池 

· 一个线程池最核心的方法就是 submit，通过 submit 提交 Runnable 任务来通知线程池来执行 Runnable 任务

· 我们简单实现一个特定线程数量的线程池，这些线程应该在线程池创建之初就被创建好，并不断尝试从任务队列中取出任务从而执行

· 所以还需一个阻塞队列用于存储 submit 提交过来的任务

· 代码实现：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;/*** @author: Themberfue* @date: 2024/10/21 21:20* @description:*/
// 实现一个固定线程数的线程池
class MyThreadPool {private BlockingQueue<Runnable> queue = null;public MyThreadPool(int n) {// 初始化线程池，创建固定个数的线程// 这里使用ArrayBlockingQueue作为任务队列, 容量为1000this.queue = new ArrayBlockingQueue<>(1000);// 创建 n 个线程for (int i = 0; i < n; i++) {Thread t = new Thread(() -> {try {while (true) {Runnable take = queue.take();take.run();}} catch (InterruptedException e) {throw new RuntimeException(e);}});// 默认为前台线程，不会正常退出程序// t.setDaemon(true);t.start();}}public void submit(Runnable task) throws InterruptedException {// 将任务放入队列中queue.put(task);}
}public class Demo34 {public static void main(String[] args) throws InterruptedException {MyThreadPool threadPool = new MyThreadPool(10);// 向线程池提交任务for (int i = 0; i < 100; i++) {int id = i;threadPool.submit(() -> {System.out.println("执行任务:" + id + " " + Thread.currentThread().getName());});}}
}

· 在执行完 100 个任务后，会发现程序并未结束，那是因为程序阻塞在了 queue.take() 中；况且线程池中的线程默认是前台线程，故不会随着主线程的结束而结束

· 在上一节的代码，看到了 shutdown 操作，也就是关闭线程池操作，该操作可以让线程池里的全部线程全部关闭，但不能保证线程池里的任务一定全部执行完毕；

· 除此之外，还提供了 awaitTermination 操作，该操作在线程池中的线程里的任务全部执行完毕后，再关闭线程池~

· 选择使用 shutdown 还是 awaitTermination 取决于任务的重要程度~

---

定时器 

· 定时器类似于闹钟，时间到了就执行相关的逻辑~

· Java 标准库中提供了 Timer 类中的 schedule 方法来延迟执行某些逻辑~：

import java.util.Timer;
import java.util.TimerTask;/*** @author: Themberfue* @date: 2024/10/22 19:24* @description:*/
public class Demo35 {public static void main(String[] args) {Timer timer = new Timer();// TimerTask是抽象类，但这里是通过创建 "匿名内部类" 的方式创建类timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("3秒过后执行");}}, 3000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("2秒过后执行");}}, 2000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("1秒过后执行");}}, 1000);System.out.println("立即执行");}
}

· 与 Runnable 类似，这里描述任务的是 TimerTask 抽象类，通过创建一个匿名类继承了 TimerTask 类并且重写了 run 方法~

---

简单实现定时器 

· 首先得有一个任务类TimerTask描述该任务逻辑

· 此外还需一个集合类来管理不同时间段要执行的任务；使用哪个集合类呢？必须得按照时间顺序执行任务，且遍历时间复杂度不能太高~ 没错，使用 优先级队列，可以快速找到哪个任务先执行

· 还需一个 schedule 方法来将任务添加到队列中

· 最后还需要额外创建一个线程来执行任务里的逻辑；此线程还需额外添加判断逻辑，与线程池的线程不同，该线程需要时间到了之后才可以执行相应的任务逻辑，时间没到就不执行，而不是直接执行

· 如何判断某任务到了时间需要执行？我们借助 时间戳 来完成这一功能，在创建 TimerTask 类时将当前 时间戳 与需要延迟执行的时间加上，循环判断当前时间戳是否达到加上后的结果；如果时间戳来到了这一结果，就说明可以执行该任务了

· 切记：既然要创建小根堆，我们需要规定该堆是按什么数值排序；在该案例中，应该是以执行该任务的延迟时间为基准，所以我们需要额外自定义一个比较器，用于小根堆的排序规则

import java.util.PriorityQueue;/*** @author: Themberfue* @date: 2024/10/22 19:32* @description:*/
class MyTimeTask implements Comparable<MyTimeTask>{// 需要执行的任务private final Runnable task;// 记录任务要执行的 "时刻"private final long time;public MyTimeTask(Runnable task, long time) {this.task = task;this.time = time;}public long getTime() {return time;}public void run() {task.run();}@Overridepublic int compareTo(MyTimeTask o) {return (int)(this.time - o.time);}
}class MyTimer {PriorityQueue<MyTimeTask> queue = null;final Object locker = new Object();public MyTimer() {// 使用优先级队列（小根堆）来管理任务执行的顺序this.queue = new PriorityQueue<>();// 创建一个线程，负责执行队列中的任务Thread t = new Thread(() -> {try {while (true) {// 涉及多个线程，一定涉及线程安全问题synchronized (locker) {// 如果队列为空，那么让该线程等待，直到offer任务到队列中// 不推荐使用continue，避免反复快速执行while循环消耗不必要的资源while (queue.isEmpty()) {// continuelocker.wait();}MyTimeTask task = queue.peek();// 当前任务时间, 如果比系统时间大, 说明任务执行的时机未到if (System.currentTimeMillis() < task.getTime()) {// 避免使用 sleep 导致程序造成问题locker.wait( task.getTime() - System.currentTimeMillis());} else {// 时间到了，执行任务task.run();queue.poll();}}}} catch (InterruptedException e) {throw new RuntimeException();}});t.start();}public void schedule(Runnable task, long delay) {synchronized (locker) {MyTimeTask timeTask = new MyTimeTask(task, System.currentTimeMillis() + delay);queue.offer(timeTask);locker.notify();}}
}public class Demo36 {public static void main(String[] args) {MyTimer myTimer = new MyTimer();myTimer.schedule(() -> {System.out.println("3秒后执行");}, 3000);myTimer.schedule(() -> {System.out.println("2秒后执行");}, 2000);myTimer.schedule(() -> {System.out.println("1秒后执行");}, 1000);System.out.println("立即执行");}
}

· 上述代码中还有一些需要注意的点：

        1. 调用 schedule 的是一个线程，定时器内部又有一个线程执行任务逻辑，那么就涉及到多线程操作，所以就可能存在线程安全问题，所以需要对程序进行加锁

        2. ，这里的最初版本其实为：if (queue.isEmpty()) { continue; } ，那为什么改了呢？如果单纯为 if 判断是否空，且 continue 到循环首行，这里确实需要等，但这里却依旧在让 CPU 消耗资源，但并没有起到实质性的作用，说白了就是空等，CPU空转；为了优化代码，将其改为上述最终版本，使用 wait 操作，便可让 CPU 暂时对这里释放资源~~~

        3. 这里可以换成 sleep 吗？当然不可以~；如果有一个程序允许时间为 11:00，有一个任务的运行时间为 11:30，此时 sleep 就会睡眠 30 分钟，若又有一个任务进来了，且它在 11:20 就要执行，但是 sleep 一旦触发，除非线程 Interrupt ，否则无法唤醒 sleep，那么就错过了后进来的任务的执行了，使用 wait，尽管是有参数版本的，依然可以被 notify 唤醒~~~

        4. 在任务量少的场景下，一个线程执行这些操作绰绰有余，但如果碰上了非常大量的任务场景，此时一个线程就有点吃不消了，所以还是建议结合线程池来使用定时器，以防不必要的事情发生~~~

---

时间轮实现定时器 

· 这里就是简单科普一下吧：交给 GPT 了~~~

设计思想

时间轮是一种环形数组结构，类似钟表的秒针。每个槽代表一个固定的时间单位（如 1 毫秒、1 秒等），每个槽可以存储多个定时任务。当时间推进时，指针在环上移动，指向当前时间对应的槽，并触发其中的任务。

执行流程

1. 定义一个固定大小的环形数组（如 360 个槽，表示 360 秒）。
2. 将定时任务根据触发时间计算分配到对应槽中：
   • 任务剩余时间 < 一圈：分配到当前圈；
   • 任务剩余时间 > 一圈：计圈数延迟，直到圈数耗尽。
3. 定时器线程按固定频率移动指针，每次移动一格：
   • 执行指针所在槽中的任务；
   • 清空已完成任务。

优点

• 高效性：插入和触发任务的时间复杂度为 O(1)。
• 节省内存：通过时间轮的槽结构减少了对定时任务的单独存储。
• 适合大规模任务：当任务数量极多，触发时间分布较广时，时间轮比优先级队列效率高。

缺点

• 时间精度受限：时间粒度由槽的间隔决定，不能无限精确。
• 复杂度较高：需要处理多圈任务，以及跨圈的边界情况。
• 不适合稀疏任务：任务密集时表现优异，但当任务稀疏且跨度大时，可能浪费大量空槽。

适用场景

• 大规模定时任务，任务时间跨度大且密集。
• 时间精度要求不高，如网络超时检测、流量限速等。

形象比喻

时间轮像一个“时钟闹铃”：每个格子是一个时间点（比如 1 秒钟后或 2 分钟后），指针每到一个格子，就检查是否有任务需要执行。

· 希望各位大佬看懂了

· 那么我们下节再见吧~~~

· 毕竟不知后事如何，且听下回分解