java 多线程之-阻塞队列

自定义阻塞队列实现

最新推荐文章于 2025-03-19 16:08:15 发布

为不为

最新推荐文章于 2025-03-19 16:08:15 发布

阅读量228

点赞数

CC 4.0 BY-SA版权

文章标签：多线程

本文链接：https://blog.youkuaiyun.com/u011747152/article/details/78233538

多线程专栏收录该内容

14 篇文章

订阅专栏

本文介绍了一个自定义的阻塞队列实现，并通过ReentrantLock进行同步控制，展示了如何在多线程环境中安全地进行元素的添加和移除操作。

public class BlockingQueueApp {
    static class BlockingQueue<T>{
        private Queue<T> queue=new LinkedList<>();
        private int capacity;
        private Lock lock=new ReentrantLock();
        private Condition notFull=lock.newCondition();
        private Condition notEmpty=lock.newCondition();
        public BlockingQueue(int capacity){
            this.capacity=capacity;
        }
        public void put(T element) throws InterruptedException{
            lock.lock();
            try{
                while(queue.size()==capacity){
                    System.out.println("队列满了");
                    notFull.await();
                }
                queue.add(element);
                System.out.println("新增"+element);
                notEmpty.signal();
            }finally {
                lock.unlock();
            }
        }
        public T take()throws InterruptedException{
            lock.lock();
            try {
                while(queue.isEmpty()){
                    System.out.println("队列已空，不能再取");
                    notEmpty.await();
                }
                T item=queue.remove();
                System.out.println("取出了"+item);
                notFull.signal();
                return  item;
            }finally {
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException{
        final BlockingQueue<Integer>blockingQueue=new BlockingQueue<>(10);
        final Random random=new Random();
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    try {
                        blockingQueue.put(random.nextInt(10));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                while (true){
                    try {
                       while (true){
                           blockingQueue.take();
                       }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread1.start();
        thread2.start();

    }
}