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

曾经终败给现在 2022-05-23 13:10 181阅读 0赞

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

#### 资源类： ####

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个资源