阻塞队列理论

关于阻塞队列在实际生活中的场景，有很多，比如银行排队，前面有人就要去等候区等待，去吃火锅发现前面作为已经满了，也要去等候区等待，这个等候区就相当于阻塞队列。

阻塞队列有以下两种特性：

当阻塞队列是空的时候，从队列中获取元素的操作像会被阻塞。直到其它线程往队列中插入元素。

当阻塞队列是满的时候，往队列中添加元素的操作将会被阻塞。直到其它线程从队列中移除一个或者多个元素或者清空队列。

为什么要用到阻塞队列？普通的线程操作不行吗？

在多线程中，所谓阻塞，就是在某些情况下线程会挂起（即阻塞），一旦条件满足，被挂起的的线程又会自动被唤醒。阻塞队列的好处是我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue都给你一手包办了。在JUC包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小复杂度。

下面简单看一下阻塞队列的架构：

Collection(Interface)<-Queue(Interface)<-BlockingQueue(Interface)

BlockingQueue的实现类有七个：

ArrayBlockingQueue:由数组结构组成的有界阻塞队列

LinkedBlockingQueue：由链表结构组成的有界（默认值是Integer.MAX_VALUE）的阻塞队列

SynchronousQueue：不存储元素的阻塞队列，也即是单个阻塞队列（0库存阻塞队列，意思就是生产出来就被别人拿走）

PriorityBlockingQueue：支持优先级排序的无界阻塞队列

DelayQueue：使用优先级队列实现的延迟无界阻塞队列

LinkedTransferQueue：由链表结构实现的无界阻塞队列

LinkedBlockingDeque：由链表结构组成的双向阻队列

 

 

关于阻塞队列的方法有很多，但是一般我们只用到了以下几种：

1，下面是抛出异常的例子

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Main{
	public static void main(String args[]) throws InterruptedException {
			//默认的队列长度是10，这里初始化为3
			BlockingQueue<String> arrayBlockingQueue=new ArrayBlockingQueue<>(3);
			System.out.println(arrayBlockingQueue.add("a"));
			System.out.println(arrayBlockingQueue.add("b"));
			System.out.println(arrayBlockingQueue.add("c"));
			
			//如果阻塞队列中的元素已经满了，当再添加的时候就抛出异常
			//System.out.println(arrayBlockingQueue.add("d"));
			
			//查找，主要作用是判断是否为空，并且返回队列的第一个元素
			System.out.println(arrayBlockingQueue.element());
			
			//下面开始删除，同样的当队列为空的时候，再次移除也会抛出异常
			System.out.println(arrayBlockingQueue.remove());
			System.out.println(arrayBlockingQueue.remove());
			System.out.println(arrayBlockingQueue.remove());
			System.out.println(arrayBlockingQueue.remove());
		
	}
}

2，这是特殊值的例子：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Main{
	public static void main(String args[]) throws InterruptedException {
			//默认的队列长度是10，这里初始化为3
			BlockingQueue<String> arrayBlockingQueue=new ArrayBlockingQueue<>(3);
			System.out.println(arrayBlockingQueue.offer("a"));
			System.out.println(arrayBlockingQueue.offer("b"));
			System.out.println(arrayBlockingQueue.offer("c"));
			
			//如果阻塞队列中的元素已经满了，当再添加的时候不会抛出异常，而是返回特殊值，像true,false,null等
			System.out.println(arrayBlockingQueue.offer("d"));
			
			//查找，主要作用是判断是否为空，并且返回队列的第一个元素
			System.out.println(arrayBlockingQueue.peek());
			
			//下面开始删除，同样的当队列为空的时候，再次移除也会抛出异常
			System.out.println(arrayBlockingQueue.poll());
			System.out.println(arrayBlockingQueue.poll());
			System.out.println(arrayBlockingQueue.poll());
			System.out.println(arrayBlockingQueue.poll());
		
	}
}

输出的是：

true
true
true
false
a
a
b
c
null

3，阻塞和超时

一直阻塞：当阻塞队列满的时候，生产者线程继续往队列中put元素，队列会一直阻塞生产线程直到put数据或者响应中断退出。当阻塞队列一直为空的时候，消费者线程试图从队列中take元素，队列会一直阻塞消费者线程直到队列可用。

具体例子可以自己尝试。

 

 

 

synchronsBlockingQueue的每一个take操作，必须要等待一个put操作。也即是零库存阻塞队列。

public class Main{
	public static void main(String args[]) throws InterruptedException {
		
			BlockingQueue<String> synchronousQueue=new SynchronousQueue<>();
			//现在开启两个线程，一个线程生产数据，另一个线程每隔5秒钟取走数据，如果不去走，那么队列就不会再插入数据
			new Thread(()->{
				try {
					System.out.println(Thread.currentThread().getName()+"put a");
					synchronousQueue.put("a");
					
					System.out.println(Thread.currentThread().getName()+"put b");
					synchronousQueue.put("b");
					
					System.out.println(Thread.currentThread().getName()+"put c");
					synchronousQueue.put("c");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			},"生产者线程").start();
			new Thread(()->{
				
			
				try {
					
					try {
						TimeUnit.SECONDS.sleep(5);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+"取走了"+synchronousQueue.take());
				
					try {
						TimeUnit.SECONDS.sleep(5);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+"取走了"+synchronousQueue.take());
				
					try {
						TimeUnit.SECONDS.sleep(2);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+"取走了"+synchronousQueue.take());
				
				
				
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			},"消费者线程").start();
		
	}
}

输出：

生产者线程put a
消费者线程取走了a
生产者线程put b
消费者线程取走了b
生产者线程put c
消费者线程取走了c