阻塞队列

1.队列
类似 排队
2.阻塞队列
顾名思义，首先是一个队列，而一个阻塞队列在数据结构中所起的作用大致如下图：

*当阻塞队列是空时，从队列获取元素的操作将会被阻塞
*当阻塞队列是满时，往队列中添加元素操作将会被阻塞
类似于 卖蛋糕的食品柜台，当柜子中没有蛋糕时，对于消费者来说 即阻塞，当柜子满时，对于做蛋糕师傅即阻塞

试图从空的阻塞队列中获取元素的线程会被阻塞，直到其它线程往空的队列插入新的元素，同样
试图往已满的队列中插入元素同样也会被阻塞，直到其它线程从列中移除一个或者多个元素或者完全清空队列后使队列重新变得空闲起来并后续新增

2.1 阻塞队列有没有好的一面
类似于饭店吃饭，店内客户已满了，再来的客户进入候客区。候客区即阻塞队列。。。
在多线程领域：所谓的阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒

为什么需要BlockingQueue
好处在于我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为阻塞队列一手包办了

在concurrent 包并发以前，在多线程环境下，我们程序员需要自己去控制这些细节，加粗样式尤其还要兼顾效率和线程安全，而这会给我门的程序带来不小的复杂度
2.2 不得不阻塞，如何管理
生产者消费者模式

3.BlockingQueue的核心方法

方法类型	异常抛出类	特殊值	阻塞	超时
插入	add(ele)	offer(ele)	put(e)	offer(e,time,unit)
移除	remove()	poll()	take()	polll(time,unit)
检查	element()	peek()	不可用	不可用

一般使用超时比较好
抛出异常:
1)当阻塞队列已满时，再往队列中add元素时，会抛出IllegalStateException:Queue full
2)当阻塞队列空时，队列中再remove 元素时会抛出NoSuchElementException
特殊值：
1）插入方法，成功返回true,失败为false
2) 异常方法，成功返回时出队列元素，队列中没有就返回null
一直阻塞：
1）当阻塞队列满时，生产者继续往队列中put元素，队列会一直阻塞生产线程直到put数据or响应中断
2）当阻塞队列空时，消费者线程试图从队列里take元素，队列会一直阻塞消费者直到队列可用
超时：
1）当向阻塞队列offer元素时候，时间超过了设定的值，就会出现超时中断；
2）当向阻塞队列poll元素时候，时间超过了设定的值，就会出现超时中断。

4.架构梳理+种类分析

4.1结构介绍

Collection > Queue > BlockingQueue > 具体实现类

4.2种类分析

*ArrayBlockingQueue*:由数组结构构成的有界阻塞队列；
*LinkedBlockingQueue*:由链表结构组成的有界（但大小默认为Integer.MAX_VALUE）阻塞队列
ProrityBlockingQueue:支持优先级排序的无界阻塞队列
DelayQueue:使用优先级队列实现的延迟无界阻塞队列
*SynchronousQueue*:不存储元素的阻塞队列，也即单个元素队列（专属定制版，消费一个生产一个）
LinkedTransferQueue:由链表组成的无界阻塞队列
LinkedBlockingDeque:由链表结构组成的双向阻塞队列

5.用在哪里

ArrayBlockingQueue:是一个基于数组结构的有序阻塞队列，此队列按FIFO 原则对元素进行排序。
LinkedBlockingQueue:一个基于链表结构的阻塞队列，此队列按FIFO 排序元素，吞吐量通常高于ArrayBlockingQueue
SynchronousQueue:一个不存储元素的阻塞队列。每个插入操作必须等到另外一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常高于LinkedBlockingQueue

volatile / CAS / atomicInteger / BlockingQueue /线程交互 / 原子引用
阻塞队列

package com.concurrent;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

class MyResource {
	// 此处使用volatile 是为了可见性 标志位
	private volatile boolean flag = true; // 默认开启，进行生产和消费
	// 生产和消费的数量
	private AtomicInteger atomicInteger = new AtomicInteger();

	// 架构程序尽量不适用具体的类
	BlockingQueue<String> blockingQueue = null;

	// 参考 spring 构造注入和设置注入（setter getter）
	public MyResource(BlockingQueue<String> blockingQueue) {
		// 打印具体的实现类 为了后期的日志查看
		System.out.println(blockingQueue.getClass().getName());

		this.blockingQueue = blockingQueue;
	}

	public void myProd() throws Exception {
		String data = null;
		boolean retValue;
		// 多线程判断 尽量使用while 防止虚假唤醒机制
		while (flag) {
			data = atomicInteger.incrementAndGet() + "";
			retValue = blockingQueue.offer(data, 2, TimeUnit.SECONDS);
			if (retValue) {
				System.out.println(Thread.currentThread().getName() + "\t 生产队列：" + data + "成功！");
			} else {
				System.out.println(Thread.currentThread().getName() + "\t 生产队列：" + data + "失败！");
			}
			TimeUnit.SECONDS.sleep(1);
		}
		

		System.out.println(Thread.currentThread().getName() + "\t 生产停工，此时的flag为false,生产动作结束！");
		return;
	}

	public void myConsumer() throws Exception {
		String result = null;
		while (flag) {
			result = blockingQueue.poll(2, TimeUnit.SECONDS);
			if (null == result || "".equals(result)) {
				flag = false;
				System.out.println(Thread.currentThread().getName() + "\t 超过两秒钟未取到数据，消费退出");
				System.out.println();
				return;
			}
			System.out.println(Thread.currentThread().getName() + "\t 消费队列：" + result + "成功");
		}
	}
	
	public void stop(){
		this.flag = false;
	}

}

/**
 * 
 * 
 * volatile / CAS / atomicInteger / BlockingQueue /线程交互 / 原子引用
 *
 */
public class ProcConsumer_BlockQueuDemo {
	public static void main(String[] args) {
		MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));
		new Thread(new Runnable() {

			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + "\t 生产线程启动！");
				try {
					myResource.myProd();
					System.out.println();
					System.out.println();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}, "Prod").start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + "\t 消费线程启动！");
				try {
					myResource.myConsumer();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}, "Consumer").start();
		
		try {
			TimeUnit.SECONDS.sleep(5);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println();
		System.out.println();
		System.out.println();
		myResource.stop();
		System.out.println("5秒钟时间到，叫停。消费和生产结束");
	}
}