Java LinkedBlockingQueue

简介

LinkedBlockingQueue是Java中的一种线程安全的阻塞队列，它实现了BlockingQueue接口并扩展了AbstractQueue类。LinkedBlockingQueue底层是通过链表实现的，可以用于实现生产者-消费者模式。

特点

LinkedBlockingQueue的特点如下：
1. 线程安全：LinkedBlockingQueue是线程安全的，多个线程可以安全地同时访问它，而不需要额外的同步措施。
2. 容量可选：LinkedBlockingQueue可以选择设置容量，当容量使用完毕时，后续的插入操作将会被阻塞，直到有空间可用。
3. 公平性：LinkedBlockingQueue提供了公平性选择，当公平性设置为true时，插入和移除操作会按照线程的到达顺序进行处理，遵循FIFO原则。

构造方法

LinkedBlockingQueue提供了多个构造方法，常用的有以下几种：
1. LinkedBlockingQueue()：创建一个无界的LinkedBlockingQueue，默认容量大小为Integer.MAX_VALUE。
2. LinkedBlockingQueue(int capacity)：创建一个具有给定容量的LinkedBlockingQueue。
3. LinkedBlockingQueue(Collection<? extends E> collection)：创建一个包含指定集合元素的LinkedBlockingQueue。

常用方法

LinkedBlockingQueue提供了丰富的方法，下面介绍一些常用的方法。
1. add(E e)：将指定元素插入队列尾部，如果队列已满，则抛出IllegalStateException异常。
2. offer(E e)：将指定元素插入队列尾部，如果队列已满，则返回false。
3. put(E e)：将指定元素插入队列尾部，如果队列已满，则阻塞直到有空间可用。
4. poll()：检索并移除队列头部的元素，如果队列为空，则返回null。
5. take()：检索并移除队列头部的元素，如果队列为空，则阻塞直到有元素可用。
6. size()：返回队列中的元素数量。

示例代码

下面是一个使用LinkedBlockingQueue实现生产者-消费者模式的示例代码：

import java.util.concurrent.LinkedBlockingQueue;

public class ProducerConsumerExample {

    private static final int MAX_CAPACITY = 10; // 队列容量
    private static LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(MAX_CAPACITY);

    // 生产者线程
    public static class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 1; i <= 20; i++) {
                try {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 消费者线程
    public static class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        Thread producerThread = new Thread(new Producer());
        Thread consumerThread = new Thread(new Consumer());

        producerThread.start();
        consumerThread.start();
    }
}

代码运行结果如下：

Produced: 1
Produced: 2
Consumed: 1
Produced: 3
Consumed: 2
Produced: 4
Consumed: 3
Produced: 5
Consumed: 4
Produced: 6
Consumed: 5
...

在这个示例中，我们定义了一个容量为10的LinkedBlockingQueue，并实现了一个生产者和一个消费者线程。生产者线程不断向队列中生产数据，而消费者线程则不断从队列中消费数据。通过使用LinkedBlockingQueue，我们可以方便地实现线程间的安全数据交换。

总结

本文介绍了Java中的LinkedBlockingQueue，它是一种线程安全的阻塞队列，常用于实现生产者-消费者模式。我们了解了LinkedBlockingQueue的特点、构造方法和常用方法，还通过示例代码演示了如何使用LinkedBlockingQueue实现生产者-消费者模式。LinkedBlockingQueue的灵活性和高效性使得它成为多线程编程中常用的工具之一。