BlockingQueue (cola de bloqueo)

BlockingQueue es una interfaz que hereda de la interfaz Queue, y la interfaz Queue hereda de Collection; las clases de implementación más utilizadas de la interfaz BlockingQueue son ArrayBlockingQueue (basado en una matriz) y LinkedBlockingQueue (basado en una lista enlazada). Las cuatro API de BlockingQueue que se usan comúnmente son:

1. 操作队列失败时会抛出异常
add（入队/添加，当队列满的时候抛出异常）
remove（出队/删除，当队列空的时候抛出异常）
element（查看队首元素，当队列空的时候抛出异常）

2. 操作队列失败的时候不会抛出异常
offer（入队/添加，当队列满的时候返回false）
poll（出队/删除，当队列空的时候返回null）
peek（查看队首元素，当队列空的时候返回null）

3. 操作队列失败的时候会阻塞，一直到可以操作为止（无限等待）
take（入队/添加，当队列满的时候阻塞等待）
put（出队/删除，当队列空的时候阻塞等待）

4. 操作队列失败的时候会阻塞一段时间，时间到则停止等待（限时等待）
入队：offer方法的重载，可以指定等待的时间，例如offer(1,5, TimeUnit.SECONDS);表示队列满的时候会阻塞5秒
出队：poll方法的重载，可以指定等待的时间，例如poll(1,5, TimeUnit.SECONDS);表示队列空的时候会阻塞5秒

BlockingQueue que bloquea la cola implementa modelos de productor y consumidor

Artículo de referencia: https://www.cnblogs.com/expiator/articles/9317929.html

/**
 * @Author Baker.chen
 * @create 2020/9/13 14:39
 *
 * 使用阻塞队列BlockingQueue实现生产者和消费者模式
 */
public class Main4 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        // 使用线程池创建线程，为了方便，直接使用Executors工具类为我们提供好的线程池
        // 实际开发中，应该避免使用这种方式，而应该自己去定义一个线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();
        threadPool.execute(new Producer(queue));
        threadPool.execute(new Consumer(queue));
    }
}
// 生产者
class Producer implements Runnable{
    
    
    private BlockingQueue queue;
    public Producer(BlockingQueue queue) {
    
    
        this.queue = queue;
    }
    @Override
    public void run() {
    
    
        for (int i = 0; i < 10; i++) {
    
    
            try {
    
    
                System.out.println("生产者生产中……");
                queue.put(i);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

// 消费者
class Consumer implements Runnable{
    
    
    private BlockingQueue queue;
    public Consumer(BlockingQueue queue) {
    
    
        this.queue = queue;
    }
    @Override
    public void run() {
    
    
        while (true) {
    
    
            try {
    
    
                System.out.println("消费者消费中……");
                System.out.println(queue.take());
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

A partir del código anterior, podemos saber que debido a las características de cola de bloqueo de BlockingQueue, la falla en la operación provocará la espera de bloqueo. Por lo tanto, es más fácil usar BlockingQueue para implementar el modelo de productor y consumidor que usar el método tradicional de espera / notificación para implementar el modelo de consumidor productor.