生产者消费者Condition实现

生产者消费者Condition实现：

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

/**
 * @Author dfpeng
 * @Date 2019/7/8
 */
public class ProducerConsumer {
    private int queueSize=10;
    private PriorityQueue<Integer> queue=new PriorityQueue<>(queueSize);
    private Lock lock=new ReentrantLock();
    private Condition notFull=lock.newCondition();
    private Condition notEmpty=lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        ProducerConsumer pc=new ProducerConsumer();
        Producer p=pc.new Producer();
        Consumer c=pc.new Consumer();
        p.start();
        c.start();
        Thread.sleep(0);
        p.interrupt();
        c.interrupt();
    }

    class Consumer extends Thread{
        @Override
        public void run() {
            consume();
        }

        volatile boolean flag=true;
        private void consume(){
            while (flag){
                lock.lock();
                try {
                    while (queue.isEmpty()){
                        try {
                            System.out.println("队列空，等待数据");
                            //等待队列不为空
                            notEmpty.await();
                        } catch (InterruptedException e) {
//                            e.printStackTrace();
                            flag=false;
                        }
                    }
                    //每次移走队首元素
                    queue.poll();
                    notFull.signal();
                    System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
                }finally {
                    lock.unlock();
                }
            }
        }
    }

    class Producer extends Thread{
        @Override
        public void run() {
            produce();
        }

        volatile boolean flag=true;
        private void produce(){
            while (flag){
                lock.lock();
                try {
                    while (queue.size()==queueSize){
                        try {
                            System.out.println("队列满，等待有剩余空间");
                            notFull.await();
                        } catch (InterruptedException e) {
//                            e.printStackTrace();
                            flag=false;
                        }
                    }
                    queue.offer(1);
                    notEmpty.signal();
                    System.out.println("向队列中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
                }finally {
                    lock.unlock();
                }
            }
        }
    }
}

运行结果：

向队列中插入一个元素，队列剩余空间：9
向队列中插入一个元素，队列剩余空间：8
向队列中插入一个元素，队列剩余空间：7
向队列中插入一个元素，队列剩余空间：6
向队列中插入一个元素，队列剩余空间：5
向队列中插入一个元素，队列剩余空间：4
向队列中插入一个元素，队列剩余空间：3
向队列中插入一个元素，队列剩余空间：2
向队列中插入一个元素，队列剩余空间：1
向队列中插入一个元素，队列剩余空间：0
队列满，等待有剩余空间
队列满，等待有剩余空间
从队列取走一个元素，队列剩余9个元素
从队列取走一个元素，队列剩余8个元素
从队列取走一个元素，队列剩余7个元素
从队列取走一个元素，队列剩余6个元素
从队列取走一个元素，队列剩余5个元素
从队列取走一个元素，队列剩余4个元素
从队列取走一个元素，队列剩余3个元素
从队列取走一个元素，队列剩余2个元素
从队列取走一个元素，队列剩余1个元素
从队列取走一个元素，队列剩余0个元素
队列空，等待数据
队列空，等待数据
向队列中插入一个元素，队列剩余空间：9
从队列取走一个元素，队列剩余0个元素

Process finished with exit code 0

欢迎关注我的微信公众号，接收最新动态。