Java并发之阻塞队列BlockingQueue —— 线程合作

前言

当试图向队列添加元素而队列已满， 或是想从队列移出元素而队列为空的时候， 阻塞队列（blocking queue ) 导致线程阻塞。在协调多个线程之间的合作时，阻塞队列是一个有用的工具。工作者线程可以周期性地将中间结果存储在阻塞队列中。其他的工作者线程移出中间结果并进一步加以修改。

方法	正常动作	特殊情况下的动作
add	添加一个元素	如果队列满，则抛出 IllegalStateException 异常
element	返回队列的头元素	如果队列空，抛出 NoSuchElementException 异常
offer	添加一个元素并返回 true	如果队列满，返回 false
peek	返回队列的头元素	如果队列空， 则返回 null
poll	移出并返回队列的头元素	如果队列空， 则返回 null
put	添加一个元素	如果队列满， 则阻塞
remove	移出并返回头元素	如果队列空， 则抛出 NoSuchElementException 异常
take	移出并返回头元素	如果队列空， 则阻塞

其中put和take是阻塞方式，会阻塞当前线程的执行。

poll和offer也可以指定阻塞时间来实现阻塞

//尝试在 100 毫秒的时间内在队列的尾部插人一个元素。如果成功返回 true ; 否则false
boolean success = q.offer(x, 100, TimeUnit.MILLISECONDS);

//尝试用 100 毫秒的时间移除队列的头元素；如果成功返回头元素，否则，达到在超时时，返回 null
Object head = q.poll(100, TimeUnit.MILLISECONDS)

BlockingQueue

LinkedBlockingQueue 构造一个带有指定的容量和公平性设置的阻塞队列。该队列用循环数组实现。

容量是没有上边界的，但是，也可以选择指定最大容量。

LinkedBlockingDeque  根据指定容量构建一个有限的阻塞队列或双向队列，用链表实现

是一个双端的版本

ArrayBlockingQueue 根据指定容量构建一个有限的阻塞队列或双向队列，用链表实现。

在构造时需要指定容量，并且有一个可选的参数来指定是否需 要公平性。若设置了公平参数， 则那么等待了最长时间的线程会优先得到处理。通常，公平性会降低性能，只有在确实非常需要时才使用它。该队列用循环数组实现。

PriorityBlockingQueue 构造一个无边界阻塞优先队列，用堆实现。

是一个带优先级的队列， 而不是先进先出队列。元素按照它们的优先级顺序被移出。该队列是没有容量上限，但是，如果队列是空的，取元素的操作会阻塞。用堆实现.

LinkedTransferQueue (1.7版本)  传输一个值， 或者尝试在给定的超时时间内传输这个值， 这个调用将阻塞，直到另一 个线程将元素删除。

LinkedTransferQueue 实现了TransferQueue接口。TransferQueue 接口，允许生产者线程等待， 直到消费者准备就绪可以接收一个元素。如果生产者调用 q.transfer(item); 这个调用会阻塞， 直到另一个线程将元素(item) 删除

SynchronousQueue

运行一个线程把对象交给另一个线程

SynchronousQueue是一个阻塞队列，其中每个一元素的插入操作必须等待另一个线程进行移除操作

用一张图来说明类之间的关系

实例

构造一个SynchronousQueue阻塞队列

public class SynchronousQueueTest {

	public static void main(String[] args) {
		//SynchronousQueue 一个阻塞队列，其中每个插入操作必须等待另一个线程执行相应的移除操作
		SynchronousQueue<Integer> queue = new SynchronousQueue<>();
		Thread t = new Thread(()->{
			System.out.println("prepare to take...");
			try {
				System.out.println("i take an element " + queue.take());
			} catch (Exception e) {
				e.printStackTrace();
			}
		});
		
		Thread t2 = new Thread(()->{
			System.out.println("prepare to put...");
			try {
				queue.put(1);
                System.out.println("has been put...");
			} catch (Exception e) {
				e.printStackTrace();
			}
		});
		t2.start();
		t.start();

	}

}

prepare to put...
prepare to take...
has been put...
i take an element 1

如果把线程一中 queue.take() 操作移除，线程二的queue.put(1)无法执行

执行结果如

prepare to take...
prepare to put...

（线程二总在执行...）

put和take使用的简单实例：

容量为1的阻塞队列，线程1会阻塞，直到线程2放入元素。

@Test
    public void test1() throws Exception{
        LinkedBlockingQueue queue = new LinkedBlockingQueue(1);
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,20,60, TimeUnit.SECONDS,new LinkedBlockingQueue(10));
        threadPoolExecutor.submit(()->{
            System.out.println("prepare to take..");
            try {
                int i =(int)queue.take();
                System.out.println("i get " + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        TimeUnit.SECONDS.sleep(3);
        threadPoolExecutor.submit(()->{
            System.out.println("prepare to put..");
            try {
                queue.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

参考：java并发编程实战

          java核心技术卷I 第14章 （第10版）