生产者和消费者问题（java简单实现）

青旅半醒 2022-06-16 08:41 187阅读 0赞

生产者消费者问题（百度百科）：生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

简单来说：按照通俗理解，我们可以想象，有一个商店仓库，可以存放的商品数量有限，制作商品的厂家（生产者）不停的将生产的商品运送到商店仓库，当商店仓库满了，厂家停止运送商品，进入停工状态。购买者（消费者）可以不停的购买商品仓库的商品，如果仓库没有商品可购买，购买者停止商品。厂家处于停工状态时需得到消费者购买掉商品的信息后，则可继续运送。购买者在无商品可买的状态下需要得到厂家已运送商品的信息后，可继续购买。

怎么知道仓库当前商品的数量呢？是否空或者是否满呢？很容易，数一下当前仓库的商品数量就行了，如果数量为0，那么仓库无货，消费者无法购买，如果数量达到仓库的容量最大值，那么仓库已满，生产者无法继续运送商品进入仓库。

由于厂家和购买者的动作时同时进行，这里容易出现问题，如果在同一时刻有一个商品进又有一个商品出，显然时无法判断仓库商品数量的，这是一个临界问题，宏观上理解就是，如果在一个教室两条门， 在有人同时进门和出门时，你无法判断教室里人的个数一样。在进教室和出教室必须有一个先后关系，也就是在同一时刻，只能有一个人进了教室，或者一个人出了教室。

所以，在java实现生产者和消费者问题时，自然而然用到了**synchronized**这个关键字，利用它控制生产者和消费者线程在并行状态下，在同一时刻，只能有一个线程操作仓库资源。

知道原理之后，代码就容易写了!

生产者线程代码:

import java.util.*;
    
    public class Producer extends Thread{
        
        //list仓库资源，消费者和生产者线程共享
        private List<Integer> list;
        private int max;//仓库能容纳资源最大数量
    
        public Producer(String name,int max,List<Integer> list){
            super(name);
            this.max=max;
            this.list=list;
        }
        public void run(){
            while(true){
                //加锁，限制在同一时刻只能有同一个线程操作仓库的资源
                synchronized(list){
                    //如果仓库资源满了，生产者无法继续生产资源，则让生产者线程等待
                    while(list.size()==max){
                        System.out.println("仓库满了！");
                        try {
                            list.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    //随机生成一个1-100的数字添加进仓库资源
                    int num=(int)(Math.random()*100)+1;
                    list.add(num);
                    System.out.println(this.getName()+"生产了"+num);
                    list.notify();//唤醒等待的消费者进程
                }
            }
        }
    
    }

消费者线程代码：

import java.util.List;
    
    public class Consumer extends Thread{
        
        //list表示仓库资源
        private List<Integer> list;
        private int max;//设置仓库最大容量
        //消费者构造函数
        public Consumer(String name,int max,List<Integer> list){
            super(name);
            this.max=max;
            this.list=list;
        }
        public void run(){
            while(true){
                //list是公用资源
                synchronized(list){
                    //如果仓库资源为空，消费者无法获取资源，则让消费者线程等待
                    while(list.isEmpty()){
                        System.out.println("仓库空了");
                        try {
                            list.wait();//线程等待
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    //否则执行消费动作
                    System.out.println(this.getName()+"正在消费"+list.get(list.size()-1));
                    list.remove(list.size()-1);//消费掉list仓库的尾部一个资源
                    list.notify();//唤醒其他所有线程
                }
            }
        }
    }

测试代码：

import java.util.ArrayList;
    import java.util.List;
    
    public class Test {
        
        public static void main(String[] args){
            List<Integer> list =new ArrayList<Integer>();
            int max=10;
            Producer p=new Producer("生产者",max,list);
            Consumer c=new Consumer("消费者",max,list);
            p.start();//开启生产者线程
            c.start();//开启消费者线程
        }
    }

代码中设计的wait()和notify()方法说明：  
不是thread方法，而是Object方法  
wait():当前线程获取对象的锁后，才调用该对象的wait方法的。调用后，该对象的等待队列中就有了一个所在线程，那个线程进入等待状态，此时，只有该对象调用notify方法，才可以把那个线程从队列里面拿出来，使这个线程成为可运行线程。  
notify():唤醒线程等待队列中的线程。由于这个程序中只有生产者和消费者两个线程，所以使用notify唤醒线程没问题。  
如果线程等待队列中有多个线程，则采用notifyAll()方法唤醒所有等待线程。