手写阻塞队列——生产者消费者模型皇冠上的宝石

本文介绍了如何通过面向接口的方式设计阻塞队列,并以链表作为底层数据结构实现。重点讲解了put和take方法的实现原理,以及如何利用ReentrantLock和Condition实现线程间的同步与阻塞。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

阻塞队列(BlockingQueue)是一个支持两个附加操作的线程安全的队列,这两个附加的操作是:在队列为空时,获取元素的线程会等待队列变为非空;当队列满时,存储元素的线程会等待队列可用。

面向接口编程,当然要先定义一个接口了:

/**
 * @description: 阻塞队列
 * @author: 張青云
 * @create: 2021-12-23 10:45
 **/
public interface MyBlockQueue<E> {
    /**
     * 向阻塞队列中插入一个元素,如果队列满了则阻塞
     */
    void put(E obj) throws InterruptedException;

    /**
     * 从阻塞队列中获取一个元素,如果队列中没有则阻塞
     */
    E take() throws InterruptedException;
}

这里我使用链表来实现了一个阻塞队列:

/**
 * @description: 链表实现的阻塞队列
 * @author: 張青云
 * @create: 2021-12-31 21:38
 **/
public class MyLinkedBlockQueue<E> implements MyBlockQueue<E> {
    /**
     * 队列的容量
     */
    private final int capacity;

    /**
     * 当前队列中的元素个数
     */
    private AtomicInteger count;

    // 用于添加元素时的锁,即队列尾部的锁
    private ReentrantLock putLock = new ReentrantLock();

    // 阻塞队列满时的等待队列
    private Condition fullCondition = putLock.newCondition();

    // 用于获取元素时的锁,即队列头部的锁
    private ReentrantLock takeLock = new ReentrantLock();

    // 阻塞队列空时的等待队列
    private Condition emptyCondition = takeLock.newCondition();

    // 链表头结点,有效数据为null
    private Node<E> head = new Node<>();

    // 链表最后一个结点
    private Node<E> tail = head;

    public MyLinkedBlockQueue(int capacity) {
        this.capacity = capacity;
        this.count = new AtomicInteger(0);
    }

    @Override
    public void put(E obj) throws InterruptedException {
        int c = -1;
        // 创建结点
        Node<E> node = new Node<>(obj);
        // 加锁
        putLock.lockInterruptibly();
        try {
            // 如果队列已经满了,则阻塞在这里
            while (count.get() == capacity) {  // 注意:这里应该使用while
                fullCondition.await();
            }
            // 将结点添加到链表中
            tail.next = node;
            tail = tail.next;
            c = count.getAndIncrement();
            // 如果有线程正在阻塞在获取元素上,则唤醒它
            if(c == 0) {
                signalNotEmpty();
            }
            if (count.get() < capacity) {
                fullCondition.signal();
            }
        } finally {
            putLock.unlock();
        }
    }

    @Override
    public E take() throws InterruptedException {
        int c = -1;
        E res;
        // 加锁
        takeLock.lockInterruptibly();
        try {
            // 如果队列为空则阻塞
            while (count.get() == 0) {
                emptyCondition.await();
            }
            // 获取队头元素
            Node<E> h = head;
            Node<E> node = h.next;
            head = node;
            res = node.val;
            head.val = null;
            c = count.getAndDecrement();
            // 如果有线程正在阻塞在添加元素上,则唤醒它
            if (c == capacity) {
                signalNotFull();
            }
            if (count.get() > 0) {
                emptyCondition.signal();
            }
        }  finally {
            takeLock.unlock();
        }
        return res;
    }

    /**
     * 通知获取元素的线程有新增元素
     */
    private void signalNotEmpty() {
        takeLock.lock();
        try {
            // 唤醒一个线程
            emptyCondition.signal();
        } finally {
            takeLock.unlock();
        }
    }

    private void signalNotFull() {
        putLock.lock();
        try {
            fullCondition.signal();
        } finally {
            putLock.unlock();
        }
    }

    static class Node<E> {
        E val;
        Node<E> next;

        public Node() {
        }

        public Node(E val) {
            this.val = val;
        }
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值