入坑JAVA多线程并发(五）生产者消费者模式

生产者消费者模式对于理解多线程是一个很经典，也很好的例子

资源类：

class Resource{
    //资源初始化个数
    private int init;
    //资源最大个数
    private int Max;

    public Resource(int init,int Max){
        this.init = init;
        this.Max = Max;
    }

    //生产资源的方法
    public synchronized void add(){
        if(init<Max){
            System.out.println(Thread.currentThread().getName()+"生产一个资源，"+"当前一共"+ ++init +"个资源");
            notifyAll();   //通知消费者消耗资源
        }else{
            try {
                System.out.println("资源已满"+Thread.currentThread().getName()+"进入休息");
                wait();    //进入休息状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //消耗资源的方法
    public synchronized void sub(){
        if(init>0){
            System.out.println(Thread.currentThread().getName()+"消费一个资源，"+"当前一共"+ --init +"个资源");
            notifyAll();   //唤醒生产者生产资源
        }else{
            try {
                System.out.println("资源已全部消耗"+Thread.currentThread().getName()+"进入等待");
                wait();    //等待资源生产
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者：

class Consumer extends Thread{

    private Resource resource;

    public Consumer(Resource resource,String name){
        super(name);
        this.resource = resource;
    }

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(100);    //休眠模拟消耗资源消耗的时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.sub();
        }
    }
}

生产者：

class Producer extends Thread{

    private Resource resource;

    public Producer(Resource resource,String name){
        super(name);
        this.resource = resource;
    }

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.add();
        }
    }
}

测试代码

    public static void main(String[] args) throws InterruptedException {
        Resource resource = new Resource(0,15);

        new Consumer(resource,"消费者1").start();
        new Consumer(resource,"消费者2").start();
        new Consumer(resource,"消费者3").start();

        new Producer(resource,"生产者1").start();
        new Producer(resource,"生产者2").start();
        new Producer(resource,"生产者3").start();
        new Producer(resource,"生产者4").start();
        new Producer(resource,"生产者5").start();
    }

输出：

生产者2生产一个资源，当前一共1个资源
生产者5生产一个资源，当前一共2个资源
生产者3生产一个资源，当前一共3个资源
生产者4生产一个资源，当前一共4个资源
消费者2消费一个资源，当前一共3个资源
消费者1消费一个资源，当前一共2个资源
消费者3消费一个资源，当前一共1个资源
生产者1生产一个资源，当前一共2个资源
生产者5生产一个资源，当前一共3个资源
生产者3生产一个资源，当前一共4个资源
生产者4生产一个资源，当前一共5个资源
生产者2生产一个资源，当前一共6个资源
生产者1生产一个资源，当前一共7个资源
消费者3消费一个资源，当前一共6个资源
消费者1消费一个资源，当前一共5个资源
消费者2消费一个资源，当前一共4个资源
生产者3生产一个资源，当前一共5个资源
生产者4生产一个资源，当前一共6个资源
生产者5生产一个资源，当前一共7个资源
生产者2生产一个资源，当前一共8个资源
消费者2消费一个资源，当前一共7个资源
生产者1生产一个资源，当前一共8个资源
消费者3消费一个资源，当前一共7个资源
消费者1消费一个资源，当前一共6个资源
生产者5生产一个资源，当前一共7个资源
生产者4生产一个资源，当前一共8个资源
生产者3生产一个资源，当前一共9个资源
生产者2生产一个资源，当前一共10个资源
消费者1消费一个资源，当前一共9个资源
消费者3消费一个资源，当前一共8个资源
生产者1生产一个资源，当前一共9个资源
消费者2消费一个资源，当前一共8个资源
生产者5生产一个资源，当前一共9个资源
生产者4生产一个资源，当前一共10个资源
生产者3生产一个资源，当前一共11个资源
生产者2生产一个资源，当前一共12个资源
生产者1生产一个资源，当前一共13个资源
消费者3消费一个资源，当前一共12个资源
消费者2消费一个资源，当前一共11个资源
消费者1消费一个资源，当前一共10个资源
生产者4生产一个资源，当前一共11个资源
生产者2生产一个资源，当前一共12个资源
生产者5生产一个资源，当前一共13个资源
生产者3生产一个资源，当前一共14个资源
消费者1消费一个资源，当前一共13个资源
生产者1生产一个资源，当前一共14个资源
消费者2消费一个资源，当前一共13个资源
消费者3消费一个资源，当前一共12个资源
生产者4生产一个资源，当前一共13个资源
生产者5生产一个资源，当前一共14个资源
生产者3生产一个资源，当前一共15个资源
资源已满生产者2进入休息
消费者3消费一个资源，当前一共14个资源
消费者2消费一个资源，当前一共13个资源
消费者1消费一个资源，当前一共12个资源
生产者1生产一个资源，当前一共13个资源
生产者3生产一个资源，当前一共14个资源
生产者5生产一个资源，当前一共15个资源
资源已满生产者4进入休息
资源已满生产者2进入休息
消费者1消费一个资源，当前一共14个资源
消费者2消费一个资源，当前一共13个资源
生产者1生产一个资源，当前一共14个资源
消费者3消费一个资源，当前一共13个资源
生产者3生产一个资源，当前一共14个资源
生产者5生产一个资源，当前一共15个资源
资源已满生产者4进入休息
资源已满生产者2进入休息
消费者1消费一个资源，当前一共14个资源
消费者2消费一个资源，当前一共13个资源
生产者1生产一个资源，当前一共14个资源
消费者3消费一个资源，当前一共13个资源
生产者5生产一个资源，当前一共14个资源
生产者3生产一个资源，当前一共15个资源
资源已满生产者4进入休息
消费者1消费一个资源，当前一共14个资源