网站301重定向检测谷歌搜索入口
这里是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 秒等），每个槽可以存储多个定时任务。当时间推进时，指针在环上移动，指向当前时间对应的槽，并触发其中的任务。
执行流程
- 定义一个固定大小的环形数组（如 360 个槽，表示 360 秒）。
- 将定时任务根据触发时间计算分配到对应槽中：
- 任务剩余时间 < 一圈：分配到当前圈；
- 任务剩余时间 > 一圈：计圈数延迟，直到圈数耗尽。
- 定时器线程按固定频率移动指针，每次移动一格：
- 执行指针所在槽中的任务；
- 清空已完成任务。
优点
- 高效性：插入和触发任务的时间复杂度为 O(1)。
- 节省内存：通过时间轮的槽结构减少了对定时任务的单独存储。
- 适合大规模任务：当任务数量极多，触发时间分布较广时，时间轮比优先级队列效率高。
缺点
- 时间精度受限：时间粒度由槽的间隔决定，不能无限精确。
- 复杂度较高：需要处理多圈任务，以及跨圈的边界情况。
- 不适合稀疏任务：任务密集时表现优异，但当任务稀疏且跨度大时，可能浪费大量空槽。
适用场景
- 大规模定时任务，任务时间跨度大且密集。
- 时间精度要求不高，如网络超时检测、流量限速等。
形象比喻
时间轮像一个“时钟闹铃”：每个格子是一个时间点（比如 1 秒钟后或 2 分钟后），指针每到一个格子，就检查是否有任务需要执行。
· 希望各位大佬看懂了
· 那么我们下节再见吧~~~
· 毕竟不知后事如何，且听下回分解
