阻塞队列的安全实现,定时器的安全实现（面试易考），超详细

一、💛

如何实现一个线程安全的阻塞队列

目前，当前代码是循环队列（还没有进行改动）

head和tail的判空判断满两种方法:

1.浪费一个格子，当前走到head的前一个位置，就认为队列满的

2.单独搞一个变量，去记录当前的元素个数（下面的代码是使用的这个）
class MyBlockingQueue{private  String[] items=new String[1000];//队列的头private int head=0;//描述队列的下一个元素，也就是正常队列的队尾private int tail=0;//统计多少个数量public  int size=0;//插入public void put(String elem){if(size>=items.length){return ;}items[tail]=elem;tail++;if(tail>=items.length){     //这一步看我下面解析tail=0;}size++;}//取出队头元素public String take(){if(size==0){return null;}String elem=items[head];head++;if(head> items.length){     //这一步看我下面解析head=0;}size--;return elem;}
}
在上述代码中，

if(tail>=items.length){
tail=0;
}这个代码和我们平时的循环队列是不是发现有点不一样，我们平时的选择是下面这个

tail=(tail+1)%item.length 但是你实际一想，他不就是把越界的给恢复到从0开始吗，所以结果一致，而且，我们写代码是两个目的：

1.让写出来的代码，开发效率高（好去理解，好修改）

2.让写出的代码，运行效率高（执行速度快）另外再补充一个小知识。cpu运算加，减，位运算，是比乘除更快一些的，乘除假如是针对（2的幂）的乘除运算，可以被优化成为位运算。

二、💙

改造（上面写的战损版）阻塞队列：

1.线程安全问题：加锁解决(直接无脑加锁（打包成原子），修改变量（count++这个类型的）的地方太多了）

2.内存可见性问题，一个线程在改，另一个线程读，内存可见性是否能够观察到修改

3.阻塞等待，wait,notify(让他等待，而不是直接返回值啥的）（插入的时候，假如说满就让他等待一会，直到你出队列，空的时候就等一会，直到你插入队列。）
class MyBlockingQueue{private  String[] items=new String[1000];//队列的头private  volatile int head=0;//描述队列的下一个元素，也就是正常队列的队尾private volatile int tail=0;//统计多少个数量public  volatile int size=0;//插入public void put(String elem) throws InterruptedException {synchronized (this) {while(size >= items.length) {this.wait();               //1号（满了就阻塞等待 4号会来唤醒1号）}items[tail] = elem;tail++;if (tail >= items.length) {tail = 0;}size++;this.notify();                //2号（2号来唤醒，3号）}}//取出队头元素public String take() throws InterruptedException {synchronized (this) {while(size == 0) {this.wait();            //3号（空了，就阻塞等待，等2号）}String elem = items[head];head++;if (head > items.length) {head = 0;}size--;this.notify();              //4号（4唤醒1号return elem;}}
}
使用wait时候，建议搭配while使用

原因：put操作之后因为队列满，进入wait阻塞了，但是过一会wait被唤醒，唤醒的时候，队列一定就是非满状态吗，万一唤醒还是满着的，此时继续执行，不就会把之前的元素覆盖了吗。

wait是一定被notify唤醒吗？

在当前代码中，如果是interrupet唤醒会报异常，方法就会结束了，但是也就不会导致刚才说的覆盖已有元素问题。但是⚠️ 假如我拿try catch阁下该如何应对捏？——一旦是被interrupt唤醒，catch执行完毕，继续执行，也就触发了“覆盖元素”的逻辑（我们这个抛异常操作是碰巧蒙对了）

所以解决方法，拿while更加万无一失

最终下图的代码：也会理解前面的一些东西
import java.util.Scanner;
import java.util.concurrent.*;class MyBlockingQueue{private  String[] items=new String[1000];//队列的头private  volatile int head=0;//描述队列的下一个元素，也就是正常队列的队尾private volatile int tail=0;//统计多少个数量public  volatile int size=0;//插入public void put(String elem) throws InterruptedException {synchronized (this) {if(size >= items.length) {this.wait();               //1号}items[tail] = elem;tail++;if (tail >= items.length) {tail = 0;}size++;this.notify();                //2号}}//取出队头元素public String take() throws InterruptedException {synchronized (this) {if (size == 0) {this.wait();            //3号}String elem = items[head];head++;if (head > items.length) {head = 0;}size--;this.notify();              //4号return elem;}}
}
public  class  Demo {public static void main(String[] args)  {MyBlockingQueue myBlockingQueue=new MyBlockingQueue();Thread t1=new Thread(()->{int count =0;while (true){try {myBlockingQueue.put(String.valueOf(count));} catch (InterruptedException e) {e.printStackTrace();}System.out.println("生产了元素"+count);count++;}});Thread t2=new Thread(()->{while(true) {Integer n = null;try {n = Integer.valueOf(myBlockingQueue.take());} catch (InterruptedException e) {e.printStackTrace();}System.out.println("消费者" + n);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t1.start();t2.start();}
}
和前面的生产者消费者模型，但是我想说的是，控制节奏，t1会快速执行到1000，后按照t2的sleep的节奏一点一点生产。

三、💜

定时器：日常开发中，常用到的组件（前后端都要用的定时器，类似于一个闹钟）

Timer类（util包)
public class Demo1 {public static void main(String[] args) {Timer timer=new Timer();timer.schedule(new TimerTask() {             //给Timer中注册的任务，不是在调用@Override                             schedule的线程中执行的，而是通过Timer     public void run() {                 内部的线程来执行的   System.out.println("hello");}},3000);                            //过了这些时间才开始执行的}
}
注意：schedule可以设置多个任务，任务的完成先后是根据等待时间的

四、💚

如何我们自己实现一个定时器（闹钟）：首先先要把任务描述出来，再用数据结构来把多个任务组织起来。

1.创建一个TimerTask这样的类，表示一个任务，该任务需包含两方面，任务的内容，任务的实际执行时间->通过时间戳表示：在schedule的时候，先获取当前系统时间，在这个基础上，加上（延时执行），得到了真实要执行这个任务的时间

2.使用一定的数据结构，把多个TimerTask组织起来

思路1（看看行不行）：咱们用（链表/数组）组织TimerTask,如果任务特别多，如何确定哪个任务，何时能够执行呢？这时候就需要搞一个线程，不断的去遍历List，进行遍历，看着里面的每个元素，是否到了时间，时间到就执行，不到就跳过下一个。

回答：不行，这个思路可以，但是非常不好，假如任务执行时间都特别长，你这段时间一直都在遍历，扫描，会很消耗cpu(还没做事）。

思路2（正解）：

1.并不需要扫描全部的任务，我们其实只需要关注一个，就是最早，时间最靠前的任务即可，最前面的任务假如还没到达的话，其他的任务更不会到达！！！

遍历一个->只关注一个，那么也就是说最好能选出最大，最小这种的数据结构（脑子里第一个肯定就是——堆（优先级队列））。

2.针对这个任务扫描，也不用一遍一遍一直重复执行，我们获取完队首时间（最小的任务时间）和当前时间做差值，在这个差值到达之前，可以让他休眠或者等待，这样不会进行重复的扫描，大幅度降低了扫描的次数->这样也不消耗cpu，（此处提高效率，不是缩短执行时间（定时器，时间是固定的），减少了资源利用率，避免了不必要的浪费）

战损没有改良的简版。

class MyTimertask{private long time;                 //任务什么时候执行，毫秒级的时间戳private Runnable runnable;         //具体的任务public MyTimertask(Runnable runnable,long delay){time=System.currentTimeMillis()+delay;this.runnable=runnable;}public long getTime() {return time;}public Runnable getRunnable() {return runnable;}
}
class MyTimer {//使用优先级队列private PriorityQueue<MyTimertask> queue = new PriorityQueue<>();//定时器核心方法public void schedule(Runnable runnable, long delay) {MyTimertask task = new MyTimertask(runnable, delay); queue.offer(task);}//定时器还要搞个扫描方法，内部的线程。一方面负责监控队首元素是否到点了，是否应该执行，// 一方面当任务到了之后，就要调用这里的Runable的run方法执行任务public MyTimer() {Thread t = new Thread(() -> {while (true) {//队列为空，此时不可以取元素if (queue.isEmpty()) {continue;}MyTimertask Task = queue.peek();long curTime = System.currentTimeMillis();if (curTime >= Task.getTime()) {queue.poll();Task.getRunnable().run();} else {try {Thread.sleep(Task.getTime() - curTime);} catch (InterruptedException e) {e.printStackTrace();}}}});t.start();}
}

当前战损版的问题：

1.线程不安全，PriorityQueue<MyTimeTask> queue=new PriorityQueue<>();

这个集合类不是线程安全的，他这个既在线程中使用，又在扫描线程中使用，给针对queue的操作进行加锁。（直接无脑暴力加锁）

2.扫描线程中的sleep是否合理呢？

（1）sleep阻塞后,不会释放锁（休眠的时候，最短的时间都还很长，这么大段时间无法添加任务）影响其他线程执行添加

（2）slepp在休眠过程中，不方便提前中断，（虽然可以用interrupt来中断，单用interrupt意味线程应该结束了）

假设当前最近的任务是14:00执行，当前时刻是13：00（sleep一小时），此时新增一个新的任务，新任务13:30要执行（成为了最早的任务），所以为了中断，应该使用wait

(3）我们设置的时候，需要把可比较写上，也就是说Comparable/Comparaor，也要知道，是什么需要比较呢，时间（顺序记不清无所谓，试一下就OK了）。

import java.util.PriorityQueue;//创建一个类，用来描述定时器中的一个任务
class MyTimertask implements Comparable<MyTimertask>{private long time;                 //任务什么时候执行，毫秒级的时间戳private Runnable runnable;         //具体的任务public MyTimertask(Runnable runnable,long delay){time=System.currentTimeMillis()+delay;this.runnable=runnable;}public long getTime() {return time;}public Runnable getRunnable() {return runnable;}@Overridepublic int compareTo(MyTimertask o) {return  (int)(this.time-o.time);}
}
class MyTimer {//使用优先级队列private PriorityQueue<MyTimertask> queue = new PriorityQueue<>();//定时器核心方法public void schedule(Runnable runnable, long delay) {synchronized (this) {MyTimertask task = new MyTimertask(runnable, delay);queue.offer(task);                     //新来一个任务，就需要把线程唤醒this.notify();}}//定时器还要搞个扫描方法，内部的线程。一方面负责监控队首元素是否到点了，是否应该执行，// 一方面当任务到了之后，就要调用这里的Runable的run方法执行任务public MyTimer() {Thread t = new Thread(() -> {while (true) {synchronized (this) {//队列为空，此时不可以取元素while (queue.isEmpty()) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}MyTimertask Task = queue.peek();               //任务的时间long curTime = System.currentTimeMillis();     //当前的系统时间if (curTime >= Task.getTime()) {               //系统时间queue.poll();               14：01>任务时间14：00 ——执行任务Task.getRunnable().run();} else {try {this.wait(Task.getTime() - curTime);} catch (InterruptedException e) {e.printStackTrace();}}}}});t.start();}
}
public class Demo3 {public static void main(String[] args) {MyTimer myTimer = new MyTimer();myTimer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("hello");}}, 3000);myTimer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("god");}}, 2000);myTimer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("good");}}, 1000);}}

这应该是自从数据结构以来，我们学过最难的了，所以大家多敲几遍理解理解