阻塞队列(BlockingQueue)接口继承了Queue接口，其有两个实现阻塞的方法：1. 移除阻塞：当队列为空时，获取队列元素的线程即队列的弹出操作会被阻塞，直到有元素被插入才被唤醒。2. 插入阻塞：当队列已满时，对这个队列的插入操作就会被阻塞，直到有元素被弹出后才会被唤醒。
阻塞队列除了在线程池工作队列里作为实现的接口外，还常用于实现生产者与消费者模型生产者是往队列里添加元素的线程，消费者是从队列里取元素的线程，而阻塞队列则用来存放“消费商品”的容器。
阻塞队列运用例子：
package ThreadPractice;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueTest {
public static void main(String[] args) {
final BlockingQueue queue = new ArrayBlockingQueue(3); // 队列的容量，超过时则阻塞
for(int i=0;i<2;i++){
new Thread(){
public void run(){
while(true){
try {
Thread.sleep((long)(Math.random()*1000));
System.out.println(Thread.currentThread().getName() + "准备放数据");
queue.put(1); // 向队列加元素
System.out.println(Thread.currentThread().getName() + "已经放了数据，" +
"队列目前有" + queue.size() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
new Thread(){
public void run(){
while(true){
try {
// sleep时间不同，会取得快取得慢，线程阻塞情况不一样
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "准备取数据");
queue.take(); // 取走数据
System.out.println(Thread.currentThread().getName() + "已经取走数据，" +
"队列目前有" + queue.size() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
======console=======
Thread-1准备放数据
Thread-1已经放了数据，队列目前有1个数据
Thread-0准备放数据
Thread-0已经放了数据，队列目前有2个数据
Thread-0准备放数据
Thread-0已经放了数据，队列目前有3个数据
Thread-1准备放数据
Thread-2准备取数据
Thread-2已经取走数据，队列目前有2个数据
Thread-1已经放了数据，队列目前有3个数据
Thread-1准备放数据
问：怎么通过阻塞队列实现之前的子主两条线程运行的程序？
答：完成代码如下：
package ThreadPractice;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
public class BlockingQueueCommunication {
public static void main(String[] args) {
final Business business = new Business();
new Thread(
new Runnable() {
@Override
public void run() {
for(int i=1;i<=50;i++){
business.sub(i);
}
}
}
).start();
for(int i=1;i<=50;i++){
business.main(i);
}
}
// 加了static后相当于内部的外部类 因为static会在类加载时就先加载
static class Business {
BlockingQueue blockingQueue1 = new ArrayBlockingQueue(1);
BlockingQueue blockingQueue2 = new ArrayBlockingQueue(1);
//(a)成员变量创建类的实例对象后才分配空间才会有值，所以通过构造方法对blockingQueue2赋值
//这里不能用static代码块，static会先加载就找不到成员变量的构造，故用这种 匿名构造方法
{ // 匿名构造方法在所有构造方法之前执行
try {
System.out.println("代码开始执行");
blockingQueue2.put(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void sub(int i) {
try {
blockingQueue1.put(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 1; j <= 10; j++) {
System.out.println("子线程循环：" + j + " 循环了：" + i);
}
try {
blockingQueue2.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void main(int i) {
try {
blockingQueue2.put(1); // 由于(a)需要阻塞所以要先放值故需要在构造器添加默认值
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 1; j <= 100; j++) {
System.out.println("主线程循环：" + j + " 循环了：" + i);
}
try {
blockingQueue1.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
注意：如果加了synchronized就会出现死锁，当线程2进入时往blockingQueue2添加数据时由于此时队列已经加了数据满了，所以线程2会阻塞，而synchronized会让线程加锁不受其他线程干扰，所以将一直处于阻塞状态。
死锁
所以阻塞队列主要利用的就是：1.队列为空取的时候阻塞 2.队列满时添加的时候会阻塞 3.队列先进先出
可以将数据存储在阻塞队列里 — 比如：生产者消费者模式
生产者与消费者模式就是一个经典的例子：
生产者消费者模式，将产生数据的线程叫做生产者，而将使用数据的线程叫做消费者。当出现生产者处理速度很快，而消费者处理速度慢的时候，那么生产者线程就要等待消费者全部处理完，同理如果消费者比生产者快就会产生等待消费者，也就是说的生产消费效率不同，因此有了生产者消费者模式。(这有点类似于工业工程上面的生产线缓存也就是我们所说的产线“超市”)
解决问题的思路就是解耦，在后面马上提到的volatile与内存空间中的关于线程的读写的高速缓存区类似的working memory工作区，即通过第三方缓存来实现对效率不对等问题的解耦操作，工厂模式也有此类的思路。线程池也有。所以通过阻塞队列实现线程间的通信，其本质就相当于一个生产者消费者的容器，当生产者生产完直接扔给阻塞队列，而不用等待消费者进行消费，消费者也不用管生产者生产而是直接从阻塞队列里面取，当阻塞队列满了再开始生产者线程阻塞，当阻塞队列取完了那么消费者线程进入阻塞直到队列又有新的资源进入非空。
