所谓的阻塞队列：就是带有阻塞特性的《——》线程安全的
- 如果队列为空，尝试出队列，就会阻塞等待，等到队列不为空为止
- 如果队列为满，尝试入队列，也会阻塞等待，等到队列不为满为止
这个东西非常有用，尤其是写多线程代码的时候，多个线程之间进行数据交互，可以使用阻塞队列来简化代码编写！
Java标准库提供了阻塞队列的使用：
import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingDeque; import java.util.concurrent.LinkedBlockingDeque; //阻塞队列 public class Main3 { public static void main(String[] args) throws InterruptedException{ // BlockingDeque<>是一个接口，不能直接new，因此，可以new一个 BlockingDeque<>的实现类LinkedBlockingDeque<>() BlockingDeque<String> queue=new LinkedBlockingDeque<>();//基于链表实现 //ArrayBlockingQueue<>()基于数组实现 //put入队列 queue.push("hello1"); queue.push("hello2"); //take出队列 String result=null; result= queue.take();//取出队首元素 System.out.println(result); result=queue.take(); System.out.println(result); result=queue.take(); System.out.println(result); } }
上述代码的运行结果为：
上述代码，入队列两次，当第三次出队列的时候，会进行阻塞！！想要解除阻塞，就需要有另一个线程往阻塞队列中放入元素！！
编写一个“生产者消费者模型”，多线程使用阻塞队列
案列：包饺子~
生产者消费者模型：初心是啥？？能解决啥问题？？
能解决的问题有很多，最主要的是俩方面：
1.可以让上下游模块之间进行更好的“解耦合”
耦合：两个模块之间的关联关系是强还是弱（关联越强，耦合越高）
写代码的要追求低耦合，避免代码牵一发动全身
内聚：
低内聚，相关联的东西没有放到一起，随便乱放的，
相关联的代码没有放到一起，东一块西一块，
高内聚：相关联的代码，分门别类的规制起来
如：两个服务器A与服务器B之间，有没有阻塞队列的情况：
2.削峰填谷
A收到的请求数量是和用户行为相关的
用户行为是随机的情况，有些情况下会出现“峰值”，暴涨一波！如果A和B是直接调用的关系，A收到峰值，B也同样收到峰值！假设A平时收到的请求是1秒1W个，突然间A收到了1秒5W个请求，则B也会1秒出现5W个请求，此时如果B设计的时候，没有考虑峰值，可能会直接挂了~~
如果有了阻塞队列这种情况：此时A收到的请求多了，队列里的元素也就多了，此时A仍然可以按照之前的速率来取元素，则队列帮B承担了压力！
比如：三峡大坝的闸门《——》削峰填谷
接下来就编写一个“生产者消费者模型”多线程使用阻塞队列的情况！
阻塞队列的简单用法：
import java.util.concurrent.BlockingDeque; import java.util.concurrent.LinkedBlockingDeque; public class Main4 { public static void main(String[] args) { //阻塞队列 BlockingDeque<Integer> blockingDeque=new LinkedBlockingDeque<>(); //用法比较简单，重点在于如何实现一个阻塞队列 //消费者 Thread t1=new Thread(()->{ while (true){ try { //从队列中取元素 int value = blockingDeque.take(); System.out.println("消费元素："+ value); } catch (InterruptedException e) { e.printStackTrace(); } } }); t1.start(); //生产者 Thread t2=new Thread(()->{ int value=0; while (true){ try { System.out.println("生产元素："+value); blockingDeque.put(value); value++; Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); //上述代码，让生产者每隔1s生产一个元素 //让消费者直接消费，不受限制 t2.start(); } }
上述代码的运行结果为：
重点：如何模拟写一个阻塞队列
泛型？？普通程序猿很少在工作中会用到
一般实现库的程序员会涉及泛型
因此再后续面试的时候，尽量不要写泛型！！（重要）
能不用泛型就不用泛型~
不用泛型，直接用朴素的代码，假定有存储的元素为int，基于数组来实现队列
class MyBlockingQueue{ private int[] items=new int[1000];//数组 //约定[head,tail)队列的有效元素 volatile private int head=0;//指向队首元素下标 volatile private int tail=0;//指向队尾元素下标 volatile private int size=0;//获取队列中的元素个数 //入队列 synchronized public void put(int elem) throws InterruptedException{ if (size==items.length){ //如果队列满了，插入失败 //return; this.wait(); //如果队列满了，就进行阻塞 //出队列的notify()唤醒 } //把新元素放到tail所在的位置上 items[tail]=elem; tail++; //万一tail达到末尾，要让tail从头再来 if (tail==items.length){ tail=0; } //一样的写法，用：tail%items.length不高效 //tail=tail%items.length;不推荐 size++; this.notify(); } //出队列 synchronized public Integer take()throws InterruptedException{ while (size==0){ //return null; this.wait(); //队列为空，阻塞等待 //入队列的notify唤醒 } int value=items[head]; head++;//队首元素下标往后走 if (head==items.length){ head=0; } size--; this.notify(); return value; } } public class Main5 { public static void main(String[] args) { MyBlockingQueue queue=new MyBlockingQueue(); //消费者 Thread t1=new Thread(()->{ while (true){ try { int value = queue.take(); System.out.println("消费："+value); Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); //生产者 Thread t2=new Thread(()->{ int value=0; while (true){ try { System.out.println("生产："+value); queue.put(value); //Thread.sleep(1000); value++; } catch (InterruptedException e) { e.printStackTrace(); } } }); t1.start(); t2.start(); } }
实现阻塞队列分为三步：
- 先实现一个普通队列
- 加上线程安全
- 加上阻塞功能
