Java并发编程 - JUC阻塞队列（BlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue、DelayQueue）

Java 并发编程中，java.util.concurrent（简称 JUC）包提供了多种阻塞队列 (BlockingQueue) 实现，包括 ArrayBlockingQueue, PriorityBlockingQueue, 和 DelayQueue。这些队列特别设计用于多线程环境，可以提高并发程序的性能和安全性。下面将详细介绍这些阻塞队列的特点及其使用方式。

阻塞队列接口（BlockingQueue）

BlockingQueue 是一个接口，它扩展了 Queue 接口，并且增加了额外的方法来支持阻塞操作。主要的阻塞方法有：

• void put(E e)：插入一个元素到队列尾部，如果队列已满，则会阻塞，直到队列不再满。
• E take()：移除队列头部的元素，并返回这个元素，如果队列为空，则会阻塞，直到队列不为空。

此外，还有一些非阻塞的方法，如 offer 和 poll，它们在无法立即执行操作时返回 false 或 null 而不是阻塞。

ArrayBlockingQueue

ArrayBlockingQueue 是一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。

特点：

• 固定大小，创建时需要指定队列的容量。
• 可选地支持公平性策略（即 FIFO 策略），默认是非公平的。
• 适用于需要固定容量的场景。

示例代码：

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

public class ArrayBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);

        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    queue.put("item-" + i);
                    System.out.println("Produced: item-" + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    String item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();

        producer.join();
        consumer.join();
    }
}

PriorityBlockingQueue

PriorityBlockingQueue 是一个无界的优先级阻塞队列。元素会按照自然顺序或者通过比较器进行排序。

特点：

• 元素按照优先级排序，优先级高的元素会被优先取出。
• 无界队列，但是可以使用构造函数设置最大容量。
• 如果没有设置最大容量，队列的大小只受限于系统内存。

示例代码：

import java.util.concurrent.PriorityBlockingQueue;

public class PriorityBlockingQueueExample {
    public static void main(String[] args) {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

        // 生产者线程
        Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                queue.offer(i);
                System.out.println("Produced: " + i);
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            while (true) {
                Integer item = queue.poll();
                if (item == null) break;
                System.out.println("Consumed: " + item);
            }
        });

        producer.start();
        consumer.start();
    }
}

DelayQueue

DelayQueue 是一个使用 Delayed 类型元素的无界阻塞队列。队列中的元素只有当其延迟过期时才能被消费。

特点：

• 专用于存储实现了 Delayed 接口的对象。
• 队列中的元素只有在其规定的延迟时间到达之后才可被消费。
• 通常用于实现定时任务等场景。

示例代码：

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class DelayQueueExample {
    public static void main(String[] args) {
        DelayQueue<DelayedElement> queue = new DelayQueue<>();

        // 添加元素
        queue.add(new DelayedElement(5, TimeUnit.SECONDS));
        queue.add(new DelayedElement(2, TimeUnit.SECONDS));

        // 消费者线程
        Thread consumer = new Thread(() -> {
            while (true) {
                DelayedElement element = queue.poll();
                if (element == null) break;
                System.out.println("Consumed after " + element.getDelay(TimeUnit.SECONDS) + " seconds");
            }
        });

        consumer.start();
    }

    static class DelayedElement implements Delayed {
        private final long triggerTime;
        private final long delayTime;

        public DelayedElement(long delay, TimeUnit unit) {
            this.delayTime = unit.toMillis(delay);
            this.triggerTime = System.currentTimeMillis() + delayTime;
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(triggerTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            return Long.compare(this.triggerTime, ((DelayedElement) o).triggerTime);
        }
    }
}

总结

这些阻塞队列各有特点，可以根据实际需求选择合适的队列类型。例如，如果你需要一个基于优先级的队列，可以选择 PriorityBlockingQueue；如果你需要一个基于延迟的队列，可以选择 DelayQueue；如果你需要一个有界队列，可以选择 ArrayBlockingQueue。

在使用这些队列时，通常会结合生产者-消费者模型来实现线程间的同步和通信。这些队列可以有效地帮助管理线程间的同步问题，提高并发性能。