生产者-消费者

梦里梦外; 2022-05-27 04:55 209阅读 0赞

产者消费者问题是多线程的一个经典问题，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。

**wait()方法**：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。  
**notify()方法**：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。

**缓冲区**

public class Storage {
        // 仓库最大存储量
        private final int MAX_SIZE = 100;
    
        // 仓库存储的载体
        private LinkedList<Object> list = new LinkedList<Object>();
    
        public int getMAX_SIZE() {
            return MAX_SIZE;
        }
    
        public LinkedList<Object> getList() {
            return list;
        }
    
        public void setList(LinkedList<Object> list) {
            this.list = list;
        }
    
        // 生产产品
        public void produce(String producer){
            synchronized (list){
                while (list.size() == MAX_SIZE){
                    System.out.println("仓库已满，【"+producer+"】： 暂时不能执行生产任务!");
                    try{
                        list.wait();
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
    
                list.add(new Object());
    
                System.out.println("【"+producer+"】：生产了一个产品\t【现仓储量为】:" + list.size());
    
                list.notifyAll();
            }
        }
    
        // 消费产品
        public void consume(String consumer) {
            synchronized (list) {
                //如果仓库存储量不足
                while (list.size()==0) {
                    System.out.println("仓库已空，【"+consumer+"】： 暂时不能执行消费任务!");
                    try {
                        // 由于条件不满足，消费阻塞
                        list.wait();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                list.remove();
                System.out.println("【"+consumer+"】：消费了一个产品\t【现仓储量为】:" + list.size());
                list.notifyAll();
            }
        }
    
    }

**生产者：**

public class Producer extends Thread{ 
        private String producer;
        private Storage storage;
    
        public String getProducer() {
            return producer;
        }
    
        public void setProducer(String producer) {
            this.producer = producer;
        }
    
        public Storage getStorage() {
            return storage;
        }
    
        public void setStorage(Storage storage) {
            this.storage = storage;
        }
    
        public Producer(Storage storage,String producer) {
            this.storage = storage;
            this.producer = producer;
        }
    
        @Override
        public void run() {
            produce(producer);
        }
    
        public void produce(String producer) {
            storage.produce(producer);
        }
    }

**消费者：**

public class Consumer extends Thread { 
        private String consumer;
        private Storage storage;
    
        public Consumer(Storage storage,String consumer) {
            this.storage = storage;
            this.consumer = consumer;
        }
    
        @Override
        public void run() {
            consume(consumer);
        }
    
        public void consume(String consumer) {
            storage.consume(consumer);
        }
    
        public String getConsumer() {
            return consumer;
        }
    
        public void setConsumer(String consumer) {
            this.consumer = consumer;
        }
    
        public Storage getStorage() {
            return storage;
        }
    
        public void setStorage(Storage storage) {
            this.storage = storage;
        }
    }

**test：**

public class Test {
        public static void main(String[] args) {
            Storage storage = new Storage();
            new Thread(new Consumer(storage,"消费者1")).start();
            new Thread(new Producer(storage,"生产者A")).start();
            new Thread(new Consumer(storage,"消费者2")).start();
            new Thread(new Producer(storage,"生产者B")).start();
            new Thread(new Producer(storage,"生产者C")).start();
            new Thread(new Consumer(storage,"消费者3")).start();
            new Thread(new Consumer(storage,"消费者4")).start();
    
        }
    }

截图：  
![这里写图片描述][70]

[70]: /images/20220527/45994e5fb78d43e19781d255822b4d96.png