ReentrantLock 实现阻塞队列 BlockingQueue

最新推荐文章于 2024-09-25 10:59:43 发布

这是靓仔呀

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量356

点赞数 1

分类专栏：笔记文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_46197019/article/details/121023928

版权

笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

这篇博客介绍了如何利用ReentrantLock来构建一个阻塞队列，包括阻塞获取、阻塞添加和超时等待获取等操作。队列内部使用LinkedList作为数据结构，并通过Condition实现线程间的同步与通信。博客中详细展示了相关方法的实现，如put、take和poll等。

摘要由CSDN通过智能技术生成

ReentrantLock 实现阻塞队列 BlockingQueue


import lombok.extern.slf4j.Slf4j;

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

//阻塞队列
@Slf4j
public class BlockingQueue<T> {
    //1. 任务队列
    private LinkedList<T> queue = new LinkedList<>();

    //2. 锁
    private final ReentrantLock LOCK = new ReentrantLock();

    //3. 生产者条件变量
    private final Condition fullWaitSet = LOCK.newCondition();

    //4. 消费者条件变量
    private final Condition emptyWaitSet = LOCK.newCondition();

    //5. 阻塞队列容量
    private int capacity;

    //超时等待获取
    public T poll(long timeout, TimeUnit timeUnit) {
        LOCK.lock();
        try {
            //将timeout 统一转换成纳秒
            long nanos = timeUnit.toNanos(timeout);
            while (queue.isEmpty()) {
                //时间超时还未等到
                if (nanos <= 0) return null;
                try {
                    nanos = emptyWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        }finally {
            LOCK.unlock();
        }
    }

    //阻塞获取
    public T take() {
        LOCK.lock();
        try {
            while (queue.isEmpty()) {
                //开始阻塞
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            //唤醒生产者线程
            fullWaitSet.signal();
            //获取队列头部元素返回
            return t;
        }finally {
            LOCK.unlock();
        }
    }

    //阻塞添加
    public void put(T e) {
        LOCK.unlock();
        try {
            while (queue.size() == size()) {
                try {
                    fullWaitSet.await();
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
            //添加元素
            queue.addLast(e);
            //唤醒消费者线程
            emptyWaitSet.signal();
        }finally {
            LOCK.unlock();
        }
    }

    //获取大小
    public int size() {
        LOCK.lock();
        try {
            return queue.size();
        }finally {
            LOCK.unlock();
        }
    }

}