生产者-消费者问题

生产者-消费者问题

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

      在如下代码中一共有一个生产者，两个消费者，生产者往容器中存放产品，最大值为10，两个消费者从容器中获取产品，当容器中产品为0的时候，消费者需要等待生产者生产后收到通知取得产品。当生产者生产的个数达到容器最大时，就停止生产，直到用户取走产品后继续生产（该模式是取走一个产品，马上补充，非等到取完再补充）

JAVA代码：

package com.consumer_producer;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class consumer_producer {

    public static void main(String[] args) {
        Container container=new Container();
        new Thread(new Producer(container)).start();

        Consumer consumer1=new Consumer(container);
        consumer1.id=1;

        Consumer consumer2=new Consumer(container);
        consumer2.id=2;

        new Thread(consumer1).start();
        new Thread(consumer2).start();
    }

}

//消费者
class Consumer implements Runnable{

    Container container=new Container();
    Integer id;

    public Consumer(Container container){
        this.container=container;
    }


    @Override
    public void run() {

        Boolean flag=true;
        while (flag)
        {
            try {
                Random random=new Random();
                Thread.sleep(random.nextInt(1000)+2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.container.get(this.id);
        }
    }
}

//生产者
class Producer implements Runnable{

    Container container=new Container();

    Integer id;

    public Producer(Container container){
        this.container=container;
    }


    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.container.push(new Product(i));
        }
    }
}

//产品
class Product{
    Integer id;

    public Product(Integer id){
        this.id=id;
    }
}


//容器
class Container{

    List<Product> producers=new ArrayList<>();

    int productnum=0;
    int count=0;

    public synchronized void push(Product product){
        if(this.count<10)
        {
            producers.add(product);
            System.out.println("生产者生产了一个产品:"+product.id);
            this.count++;
            this.productnum++;

            this.notifyAll();
        }
        else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void get(Integer id){

        if(this.count>0)
        {
            System.out.println("消费者"+id+"取消走了产品"+producers.get(this.productnum-count).id);
            this.count--;
        }
        else
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            this.notifyAll();
        }

    }

}

运行结果：

生产者生产了一个产品:0
生产者生产了一个产品:1
消费者1取消走了产品0
消费者2取消走了产品1
生产者生产了一个产品:2
生产者生产了一个产品:3
生产者生产了一个产品:4
消费者1取消走了产品2
消费者2取消走了产品3
生产者生产了一个产品:5
生产者生产了一个产品:6
消费者1取消走了产品4
消费者2取消走了产品5
生产者生产了一个产品:7
生产者生产了一个产品:8
生产者生产了一个产品:9
消费者2取消走了产品6
消费者1取消走了产品7
生产者生产了一个产品:10
生产者生产了一个产品:11
生产者生产了一个产品:12
消费者1取消走了产品8
消费者2取消走了产品9
生产者生产了一个产品:13
生产者生产了一个产品:14
生产者生产了一个产品:15
消费者2取消走了产品10
消费者1取消走了产品11
生产者生产了一个产品:16
生产者生产了一个产品:17
消费者2取消走了产品12
消费者1取消走了产品13
生产者生产了一个产品:18
生产者生产了一个产品:19
消费者2取消走了产品14
消费者1取消走了产品15
消费者2取消走了产品16
消费者1取消走了产品17
消费者2取消走了产品18
消费者1取消走了产品19

若有任何问题，请指正！