BlockingQueue

àì夳堔傛蜴生んèń 2021-12-16 03:51 241阅读 0赞

**定义**  
　　阻塞队列 (BlockingQueue)是Java util.concurrent包下重要的数据结构，BlockingQueue提供了线程安全的队列访问方式：当阻塞队列进行插入数据时，如果队列已满，线程将会阻塞等待直到队列非满；从阻塞队列取数据时，如果队列已空，线程将会阻塞等待直到队列非空。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。并发包下很多高级同步类的实现都是基于BlockingQueue实现的。

**核心方法**  
　　offer(E e): 将给定的元素设置到队列中，如果设置成功返回true, 否则返回false. e的值不能为空，否则抛出空指针异常。  
　　offer(E e, long timeout, TimeUnit unit): 将给定元素在给定的时间内设置到队列中，如果设置成功返回true, 否则返回false.  
　　add(E e): 将给定元素设置到队列中，如果设置成功返回true, 否则抛出异常。如果是往限定了长度的队列中设置值，推荐使用offer()方法。

put(E e): 将元素设置到队列中，如果队列中没有多余的空间，该方法会一直阻塞，直到队列中有多余的空间。  
　　take(): 从队列中获取值，如果队列中没有值，线程会一直阻塞，直到队列中有值，并且该方法取得了该值。  
　　poll(long timeout, TimeUnit unit): 获取并移除此队列的头元素，可以在指定的等待时间前等待可用的元素，timeout表明放弃之前要等待的时间长度，用 unit 的时间单位表示，如果在元素可用前超过了指定的等待时间，则返回null，当等待时可以被中断  
　　remainingCapacity()：获取队列中剩余的空间。  
　　remove(Object o): 从队列中移除指定的值。  
　　contains(Object o): 判断队列中是否拥有该值。  
　　drainTo(Collection c): 将队列中值，全部移除，并发设置到给定的集合中。

**实现类**  
　BlockingQueue 是个接口，你需要使用它的实现之一来使用BlockingQueue，Java.util.concurrent包下具有以下 BlockingQueue 接口的实现类：

**ArrayBlockingQueue**：ArrayBlockingQueue 是一个有界的阻塞队列，其内部实现是将对象放到一个数组里。有界也就意味着，它不能够存储无限多数量的元素。它有一个同一时间能够存储元素数量的上限。你可以在对其初始化的时候设定这个上限，但之后就无法对这个上限进行修改了(译者注：因为它是基于数组实现的，也就具有数组的特性：一旦初始化，大小就无法修改)。  
　　**DelayQueue**：DelayQueue 对元素进行持有直到一个特定的延迟到期。注入其中的元素必须实现 java.util.concurrent.Delayed 接口。  
　　**LinkedBlockingQueue**：LinkedBlockingQueue 内部以一个链式结构(链接节点)对其元素进行存储。如果需要的话，这一链式结构可以选择一个上限。如果没有定义上限，将使用 Integer.MAX\_VALUE 作为上限。  
　　**PriorityBlockingQueue**：PriorityBlockingQueue 是一个无界的并发队列。它使用了和类 java.util.PriorityQueue 一样的排序规则。你无法向这个队列中插入 null 值。所有插入到 PriorityBlockingQueue 的元素必须实现 java.lang.Comparable 接口。因此该队列中元素的排序就取决于你自己的 Comparable 实现。  
　　**SynchronousQueue**：SynchronousQueue 是一个特殊的队列，它的内部同时只能够容纳单个元素。如果该队列已有一元素的话，试图向队列中插入一个新元素的线程将会阻塞，直到另一个线程将该元素从队列中抽走。同样，如果该队列为空，试图向队列中抽取一个元素的线程将会阻塞，直到另一个线程向队列中插入了一条新的元素。据此，把这个类称作一个队列显然是夸大其词了。它更多像是一个汇合点

**实例：**

生产者消费者的示例代码

生产者：

public class Producer implements Runnable {  
        BlockingQueue<String> queue;  
      
        public Producer(BlockingQueue<String> queue) {  
            this.queue = queue;  
        }  
      
        @Override  
        public void run() {  
            try {  
                String temp = "A Product, 生产线程："  
                        + Thread.currentThread().getName();  
                System.out.println("I have made a product:"  
                        + Thread.currentThread().getName());  
                queue.put(temp);//如果队列是满的话，会阻塞当前线程  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
      
    }

消费者：

public class Consumer implements Runnable{  
        BlockingQueue<String> queue;  
          
        public Consumer(BlockingQueue<String> queue){  
            this.queue = queue;  
        }  
          
        @Override  
        public void run() {  
            try {  
                String temp = queue.take();//如果队列为空，会阻塞当前线程  
                System.out.println(temp);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }

测试类：

public class Test3 {  
      
        public static void main(String[] args) {  
            BlockingQueue<String> queue = new LinkedBlockingQueue<String>(2);  
            // BlockingQueue<String> queue = new LinkedBlockingQueue<String>();  
            //不设置的话，LinkedBlockingQueue默认大小为Integer.MAX_VALUE  
              
            // BlockingQueue<String> queue = new ArrayBlockingQueue<String>(2);  
      
            Consumer consumer = new Consumer(queue);  
            Producer producer = new Producer(queue);  
            for (int i = 0; i < 5; i++) {  
                new Thread(producer, "Producer" + (i + 1)).start();  
      
                new Thread(consumer, "Consumer" + (i + 1)).start();  
            }  
        }  
    }

打印结果：

I have made a product:Producer1  
    I have made a product:Producer2  
    A Product, 生产线程：Producer1  
    A Product, 生产线程：Producer2  
    I have made a product:Producer3  
    A Product, 生产线程：Producer3  
    I have made a product:Producer5  
    I have made a product:Producer4  
    A Product, 生产线程：Producer5  
    A Product, 生产线程：Producer4

由于队列的大小限定成了2，所以最多只有两个产品被加入到队列当中，而且消费者取到产品的顺序也是按照生产的先后顺序，原因就是LinkedBlockingQueue和ArrayBlockingQueue都是按照FIFO的顺序存取元素的。

关于更加详细的BlockingQueue的分析请看这篇：[解读 Java 并发队列 BlockingQueue][Java _ BlockingQueue]

原文：https://blog.csdn.net/wuzhiwei549/article/details/79869699

转载于:https://www.cnblogs.com/myseries/p/10944553.html

[Java _ BlockingQueue]: http://www.importnew.com/28053.html