java 并发包 Lock Condition实现阻塞队列

最新推荐文章于 2025-02-21 18:49:56 发布

原创最新推荐文章于 2025-02-21 18:49:56 发布 · 421 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #实现 #阻塞队列 #lock

java 专栏收录该内容

19 篇文章

订阅专栏

本文介绍了一个使用Java的ReentrantLock和Condition实现的线程安全队列。该队列能够处理多个生产者和消费者之间的同步问题，通过信号量机制确保线程间的正确通信，避免死锁。文章详细展示了如何在队列满或空时，让生产者或消费者线程等待，直到条件改变。

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

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

public class LockConditionTest {

    public static void main(String[] args) {

        MyQueue<String> queue = new MyQueue<>(5);
        while(true){
            try {
                Thread.sleep(0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            new Thread(()->{
                String s = queue.get();
                System.out.println("发送消息："+s);
            }).start();

            new Thread(()->{
                String set = new Random().nextInt()*1000+"";
                queue.put(set);
                System.out.println("存储消息："+set);
            }).start();

            System.out.println("对列长度："+queue.getCount());
        }

    }


    static class MyQueue<OBJ>{

        private final int total;//最大长度
        private List<OBJ>  list; //对列
        private Lock lock = new ReentrantLock(); //锁
        private Condition notFull = lock.newCondition();//不满
        private Condition notEmpty = lock.newCondition(); //不为空

        public MyQueue(int total){
            this.total = total;
            list = new LinkedList<>();
        }

        public int getCount(){
            return this.list.size();
        }

        public void put(OBJ obj){
            lock.lock();
            try{
                //如果满了,则阻塞
                if(list.size() >= total){
                    try {
                        System.out.println("满了，等待发送");
                        this.notFull.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                list.add(obj);

                //不为空唤醒
                notEmpty.signal();
            }finally {
                lock.unlock();
            }
        }

        public OBJ get(){
            lock.lock();
            try{
                if(list.isEmpty()){
                    try {
                        System.out.println("没有信息了，等待注入");
                        notEmpty.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                OBJ obj = list.remove(0);
                notFull.signal();
                return obj;
            }finally {
                lock.unlock();
            }
        }
    }
}