队列的学习（三） 手写一个阻塞队列

队列的学习（三） 手写一个阻塞队列

本文将介绍如何手写一个阻塞队列。阻塞队列是一种线程安全的队列，当队列为空时，消费者线程将被阻塞直到队列中有元素可供消费；当队列已满时，生产者线程将被阻塞直到队列有空闲位置可供插入元素。

阻塞队列的实现

我们可以使用 Java 提供的 Lock 和 Condition 接口来实现阻塞队列。具体实现如下：

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BlockingQueue<T> {

    private LinkedList<T> queue;
    private int capacity;
    private Lock lock;
    private Condition notFull;
    private Condition notEmpty;

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
        queue = new LinkedList<>();
        lock = new ReentrantLock();
        notFull = lock.newCondition();
        notEmpty = lock.newCondition();
    }

    public void put(T element) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                notFull.await();
            }
            queue.add(element);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            T element = queue.remove();
            notFull.signal();
            return element;
        } finally {
            lock.unlock();
        }
    }
}

在上述代码中，我们使用了 LinkedList 作为队列的底层数据结构，使用 Lock 和 Condition 接口来实现阻塞队列，其中：

• lock 用于同步队列的插入和删除操作；
• notFull 用于在队列已满时阻塞生产者线程；
• notEmpty 用于在队列为空时阻塞消费者线程。

阻塞队列的使用

使用阻塞队列时，我们需要先创建一个阻塞队列对象，指定队列的容量，然后在生产者线程中调用 put 方法向队列中插入元素，在消费者线程中调用 take 方法从队列中获取元素。具体使用方法如下：

public static void main(String[] args) throws InterruptedException {
    BlockingQueue<Integer> queue = new BlockingQueue<>(10);

    new Thread(() -> {
        for (int i = 0; i < 20; i++) {
            try {
                queue.put(i);
                System.out.println("Producer put: " + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();

    new Thread(() -> {
        for (int i = 0; i < 20; i++) {
            try {
                Integer element = queue.take();
                System.out.println("Consumer take: " + element);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();
}

在上述代码中，我们创建了一个容量为 10 的阻塞队列，启动了一个生产者线程和一个消费者线程，生产者线程向队列中插入了 20 个元素，消费者线程从队列中取出了 20 个元素。

总结

阻塞队列是一种常用的线程安全队列，可以有效地协调生产者和消费者线程的工作。本文介绍了如何手写一个阻塞队列，并提供了使用示例。希望本文能够对大家学习阻塞队列有所帮助！