Java多线程基础-10：代码案例之定时器（一）+ https://developer.aliyun.com/article/1520548?spm=a2c6h.13148508.setting.14.75194f0ethWdBZ
c.给队列中的MyTask元素设定优先级
PriorityBlockingQueue与PriorityQueue指定建堆顺序的方式是类似的。既可以通过将比较器Comparator传入构造器，也可以直接在元素中实现Comparable接口和compareTo方法。
这里我们只需让MyTask类实现Comparable接口，并以时间time为依据实现compareTo()方法即可。
回顾：PriorityQueue指定比较顺序的方式
在优先级队列中，元素的排序依赖于它们的比较结果。可以通过实现Comparable接口并定义compareTo()方法来指定对象之间的排序规则。这样，优先级队列就能根据对象的比较结果对元素进行自动排序。
如果不希望修改原始对象的类（或无法修改它），也可以创建一个实现了Comparator接口的单独类用于比较对象，并将该比较器作为参数传递给优先级队列的构造函数。使用比较器可以在不修改原始类的情况下定义对象之间的排序规则。
如果在构造Priorityqueue时没有提供比较器，而是使用实现了Comparable接口的对象的compareTo方法进行比较，那么优先级队列将根据该方法的比较结果进行排序。
如果对象没有实现Comparable接口或没有定义compareTo方法，也没有额外提供比较器，那么在添加元素时可能会抛出classCastException，因为优先级队列无法确定对象之间的顺序。
class MyTask implements Comparable<MyTask>{ public Runnable runnable; public long time; //为了方便后续判定，使用的是绝对的时间戳 public MyTask(Runnable runnable, long delay) { this.runnable = runnable; this.time = System.currentTimeMillis() + delay; //转换：相对时间delay + 当前时间戳 => 绝对的时间戳 } //指定比较规则 @Override public int compareTo(MyTask o) { return (int)(this.time-o.time); } }
（tips：在写compareTo()时，可以不可以记忆到底是谁减去谁。可以先随便写一种，然后运行看看效果。如果不对再改成另一种相减方式。）
d.解决CPU的忙等问题
忙等，即虽然CPU确实在“等待”，但它也没捞着休息。就好比原本规定早上8点出门，我早上醒来后看了一眼手表，此时是7点，发现时间还没到；而过1分钟我又看一次表，发现是7点01，时间还没到；又过了1分钟我又去看表，此时是7点02，时间还没到……剩下的时间里我光顾着看表，也没有好好休息。
忙等在上述代码中表现为，while (true) 转的太快了，造成了无意义的 CPU 浪费。比如第一个任务设定的是 1 min 之后执行某个逻辑，但是这里的 while (true) 会导致每秒钟访问队首元素几万次，而当前距离任务执行的时间还有很久，剩下的时间里CPU光顾着进进出出访问队首元素了。
我们需要在等待的过程中释放CPU。
有同学可能会提出使用sleep()，但sleep()不是一个好的选择，因为sleep()的时间必须是固定的。如果sleep()的时间过长，恰好错过了任务的执行时间（睡过头了），就不妙了。
使用wait()就比较合适，可以随时提前结束。在等待过程中随时有新的任务过来，CPU就可以随时去处理。
所以代码逻辑更改为，如果时间还没到，则将刚取出的队首元素放回队列，并进入wait()等待直到时间到。而在插入队列元素时，必须调用notify()方法唤醒锁对象。代码如下：
//自定义定时器类 class MyTimer { //显式地指定锁对象：locker private Object locker = new Object(); //核心数据结构，带有优先级的阻塞队列 private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>(); //此处的delay是一个相对时间，表示间隔多少时间后执行该任务 public void schedule(Runnable runnable, long delay) { //根据参数构造MyTask，插入队列即可 MyTask myTask = new MyTask(runnable,delay); queue.put(myTask); //唤醒正在等待的线程********************************* synchronized (locker) { locker.notify(); } } // 在这里构造线程，负责不停地扫描队首元素，判断该任务是否可以执行 public MyTimer() { Thread t = new Thread(()->{ while (true) { try { //wait 必加锁 synchronized (locker) { MyTask myTask = queue.take(); long curTime = System.currentTimeMillis(); //获取当前时间 if(curTime < myTask.time) { //当前时间小于任务时间：时间还没到 //暂不执行，要把刚才取出的任务塞回队列中 queue.put(myTask); //等待该任务的时间到***************************************** locker.wait(myTask.time - System.currentTimeMillis()); }else{ //时间到了，执行任务 myTask.runnable.run(); //执行任务 } } } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); } }
为什么要在schedule方法中唤醒线程？其实也不难理解。
打个比方，比如当前时刻是 14：00 ，约定了 14:30 要执行上课这个任务。取出队首元素，发现时间是14：00，还没到，按逻辑就需要 wait 等待 30 分钟。
而在等待过程中，一个新的任务来了，14:10 要去接水。这样一来，就不能放任刚才的 wait 继续等了，而是需要唤醒 wait，此时工作线程就会重新取队首元素，这时取到的元素就是14：10去接水这个任务。这样做能够保证无论什么时候插入新任务，工作线程都能正确地把最小时间的任务取到。
在上述代码中，在schedule 方法中使用notify的目的是通知等待在locker对象上的线程。这是为了确保当添加新任务时，如果有线程正在等待队列中的任务执行完成，它能够被唤醒并重新检查队列。
因为在定时器类中的线程通过locker.wait(myTask.timeSystem.currentTimeMillis())进行等待，以等待下一任务的执行时间到来。如果没有通知等待的线程，即使有新任务加入队列，等待的线程也会继续等待，而不会重新检查队列是否有更早需要执行的任务。
因此，在schedule方法中调用notify是为了确保正在等待的线程能够及时得到通知，以重新检查队列并执行更早的任务。
2、完整代码
import java.util.*; import java.util.concurrent.PriorityBlockingQueue; class MyTask implements Comparable<MyTask>{ public Runnable runnable; public long time; //为了方便后续判定，使用的是绝对的时间戳 public MyTask(Runnable runnable, long delay) { this.runnable = runnable; this.time = System.currentTimeMillis() + delay; //转换：相对时间delay + 当前时间戳 => 绝对的时间戳 } @Override public int compareTo(MyTask o) { return (int)(this.time-o.time); } } //自定义定时器类 class MyTimer { //显式地指定锁对象：locker private Object locker = new Object(); //核心数据结构，带有优先级的阻塞队列 private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>(); //此处的delay是一个相对时间，表示间隔多少时间后执行该任务 public void schedule(Runnable runnable, long delay) { //根据参数构造MyTask，插入队列即可 MyTask myTask = new MyTask(runnable,delay); queue.put(myTask); synchronized (locker) { locker.notify(); } } // 在这里构造线程，负责不停地扫描队首元素，判断该任务是否可以执行 public MyTimer() { Thread t = new Thread(()->{ while (true) { try { //wait 必加锁 synchronized (locker) { MyTask myTask = queue.take(); long curTime = System.currentTimeMillis(); //获取当前时间 if(curTime < myTask.time) { //当前时间小于任务时间：时间还没到 //暂不执行，要把刚才取出的任务塞回队列中 queue.put(myTask); locker.wait(myTask.time - System.currentTimeMillis()); }else{ //时间到了，执行任务 myTask.runnable.run(); //执行任务 } } } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); } } public class ThreadDemo { public static void main(String[] args) { MyTimer myTimer = new MyTimer(); //注册任务 myTimer.schedule(()->{ System.out.println("AAA"); },4000); myTimer.schedule(()->{ System.out.println("BBB"); },3000); myTimer.schedule(()->{ System.out.println("CCC"); },2000); myTimer.schedule(()->{ System.out.println("DDD"); },1000); System.out.println("EEE"); } }
运行，查看结果：
三、MyTimer中加锁位置的问题
前面提到，要用wait()和notify()来解决CPU忙等的问题。但是，synchronized的书写位置是会影响结果的正确性的。
现在有以下两种加锁方式：
第一种：
第二种：
其中，第一种方式是正确的加锁方式，第二种方式则会引发线程安全问题。第二种方式会引发何种线程安全问题？为什么？
1、分析
分析这个问题的要点是：线程的调度是随机的、无序的。
在第二种代码书写的情况下，假设执行到put之后就切走了：
t2执行完后，再调度回t1，接下来t1再继续执行到wait()。此时t1将要wait的时间仍是30分钟！这里的wait就导致新加入的要求8：10执行的任务无法及时执行了！
也就是说，t1错过了notify，只会一直等下去直到时间到，但这样就完全忽略了新加入的比当前更早的任务。
而正常的情况下（第一种代码书写的情况下），还是假设执行到put就切走了：
加锁保证了黄色框中的所有操作都是原子的。
2、知识点补充
a.为什么有wait就必须加锁？
在Java中wait()方法是Object类的方法，用于将当前线程置于等待状态，并释放对象的锁。在使用wait()方法之前，必须先获得对象的锁（即在synchronized代码块中）。
wait()方法必须在synchronized代码块中调用：
1. 锁的拥有者才有资格等待和被唤醒：只有获得对象的锁，即当前线程是锁的拥有者，才能调用wait()方法。这是为了避免在没有持有锁的情况下调用wait()方法导致的不确定行为。
2. 释放对象的锁：wait()方法被调用后，当前线程会释放对象的锁，以便其他线程有机会获得锁并执行相应的同步代码。
3. 防止竞态条件：在多线程环境下，wait()方法和唤醒操作（notify()或notifyAll()）之间可能存在竞态条件。通过将wait()方法的调用放在同步代码块中，可以确保只有一个线程能够调用wait()方法，避免了竞态条件的发生。
b.什么是竞态条件？
竞态条件（Race Condition）是指多个线程或进程在并发执行时，由于执行顺序的不确定性而导致的结果依赖于线程或进程执行的相对速度和时序的现象。
在并发编程中，竞态条件可能会导致意外的结果，甚至破坏程序的正确性。竞态条件通常发生在多个线程同时访问和操作共享资源时，其中至少一个线程进行写操作。
下面是一些常见的竞态条件情况：
1. 读-修改-写操作：多个线程同时读取某个共享变量的值，然后基于该值进行修改并写回。由于线程之间的执行时序不确定，可能会导致竞争条件和不一致的结果。
2. 检查-执行操作：多个线程同时检查某个条件，如果满足条件则执行相应的操作。如果多个线程同时检查条件，并根据条件结果进行操作，可能会导致竞态条件和操作冲突。
3. 线程间通信问题：当多个线程之间进行通信或协调时，如果没有适当的同步机制，可能会导致竞态条件。例如，一个线程等待另一个线程的完成信号，但无法确保在接收到信号之前线程已经完成。
竞态条件可能导致不正确的结果、数据损坏、死锁或其他意外行为。为了避免竞态条件，需要使用同步机制（如锁、互斥量、信号量等）来协调线程之间的访问和操作共享资源的顺序。同步机制可以确保在访问共享资源时，只有一个线程能够进行操作，从而避免竞态条件的发生。
c.对方法加锁，锁对象如何确定？
当一个方法被声明为synchronized时，它将被视为一个临界区，只有一个线程可以进入该方法执行，其他线程必须等待。
1、对于非静态方法，锁对象是实例对象（即调用该方法的对象），通常使用this关键字作为锁对象。当一个线程进入synchronized方法时，它会自动获取该方法所属对象的锁（即锁定当前实例对象），其他线程需要等待锁释放才能执行相同实例对象的synchronized方法。
public class MyClass { public synchronized void synchronizedMethod() { // 方法体 } }
在上面的示例中，锁对象是调用SynchronizedMethod()方法的实例对象（即this）。
2、对于静态方法，锁对象是该类的Class对象。静态方法属于类级别，与实例对象无关，因此使用类的Class对象作为锁对象。
示例代码如下：
public class MyClass { public static synchronized void synchronizedStaticMethod() { // 方法体 } }
在上面的示例中，锁对象是MyClass.class。
需要注意的是，锁对象的选择应根据具体的需求和同步策略来确定。有时候，需要使用特定的对象作为锁对象，而不是默认的实例对象或类对象。如多个方法共享同一个锁对象。
d.调用wait会释放锁
当线程在锁对象上调用wait()方法时，它会释放该对象上持有的锁（也称为监视器），从而允许其他线程获取该锁并执行synchronized代码。wait()方法还会将调用线程置于等待状态，直到被通知或中断。
调用wait()方法时涉及的步骤如下：
1. 线程释放它在对象上持有的锁。
2. 线程进入等待状态，直到被其他线程通知或中断。
3. 一旦线程被通知（通过同一对象上的notify()或notifyAll()方法）或被中断，它将尝试重新获取锁。
4. 当线程成功重新获取锁时，它可以从上次离开的地方继续执行。
在wait()期间释放锁，允许其他线程获取锁并执行同步代码，从而促进线程之间的并发性和协调性。
需要注意的是，为了确保正确的同步并避免出现非法监视器状态异常，应该始终在同步块或同步方法中使用相同的对象作为锁，并在其中调用wait()方法。
