生产者和消费者模式实现(一)

生产者和消费者模式

• 生产者 生产数据到队列中，消费者从队列中取出数据并消费
• 关键字synchronized对数据加锁，用Object原生的wait()和notify()做同步

Java 代码

import java.util.LinkedList;
import java.util.Queue;

public class ProducerAndConsumer {
    //队列中最多容纳元素个数
    private final int MAX_LEN=10;
    //可能会产生并发冲突的资源(队列)
    private Queue<Integer> queue=new LinkedList<>();

    //生产者类
    class Producer extends  Thread
    {
        @Override
        public void run() {
            producer();
        }
        public  void producer()  {

            while (true) {
                synchronized (queue) {
                    while (queue.size()==MAX_LEN)
                    {
                        System.out.println("当前队列已满");
//                        通知消费者消费
                        queue.notify();
                        try {
                            //队列满生产者需要等待
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //生产者生产
                    queue.offer(1);
                    //通知消费者消费
                    queue.notify();
                    System.out.println("生产者生产一条消息，当前队列长度为： "+ queue.size());
                    //模拟实际业务所需时间
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {


                    }
                }
            }

        }

    }
    //消费者类
    class Consumer extends  Thread
    {
        @Override
        public void run() {
            consumer();
        }

        public void consumer()
        {
            while (true) {
                synchronized (queue) {
                    while(queue.isEmpty())
                    {

                        System.out.println("当前队列已空");
                        //通知生产者生产
                        queue.notify();
                        try {
                            //队列空消费者需要等待
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }
                    //消费者消费
                    queue.poll();
                    //通知生产者生产
                    queue.notify();
                    System.out.println("消费者消费一条消息，当前队列长度为： "+ queue.size());
                    //模拟实际业务所需时间
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {


                    }
                }
            }


        }
    }

    public static void main(String[] args) {

        ProducerAndConsumer pc=new ProducerAndConsumer();

        Producer producer = pc.new Producer();
        Consumer consumer = pc.new Consumer();

        //启动生产者线程
        producer.start();
        //启动消费者线程
        consumer.start();
    }
}

结果

生产者生产一条消息，当前队列长度为： 1
生产者生产一条消息，当前队列长度为： 2
生产者生产一条消息，当前队列长度为： 3
生产者生产一条消息，当前队列长度为： 4
生产者生产一条消息，当前队列长度为： 5
生产者生产一条消息，当前队列长度为： 6
生产者生产一条消息，当前队列长度为： 7
消费者消费一条消息，当前队列长度为： 6
消费者消费一条消息，当前队列长度为： 5
消费者消费一条消息，当前队列长度为： 4
消费者消费一条消息，当前队列长度为： 3
消费者消费一条消息，当前队列长度为： 2
消费者消费一条消息，当前队列长度为： 1
消费者消费一条消息，当前队列长度为： 0
当前队列已空
生产者生产一条消息，当前队列长度为： 1
生产者生产一条消息，当前队列长度为： 2
生产者生产一条消息，当前队列长度为： 3
消费者消费一条消息，当前队列长度为： 2