【JUC】生产者消费者问题（包含虚假唤醒问题）

参考文章

【操作系统】生产者消费者问题_liushall-CSDN博客_生产者消费者问题操作系统

概念

生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。

 

可以理解为肯德基买炸鸡，

        生产者就相当于肯德基的后厨，生产炸鸡并放到前台

        消费者就相当于顾客，从前台获得炸鸡

        有限的缓冲区就相当于前台的保温柜里能放几只炸鸡

        但是生产炸鸡的时候顾客不能购买，购买炸鸡的时候后厨不能生产

注意事项：

        当缓冲区（前台）为空时，消费者（顾客）不能再进行消费

        当缓冲区（前台）为满时，生产者（后厨）不能再进行生产

        在线程进行生产或消费时，其余线程不能再进行生产或消费等操作，即保持线程的同步

通过传统synchronized锁来实现生产者消费者问题

实现生产者消费者问题的代码逻辑为

 也既，先判断满不满足条件，不满足让出CPU，直到再次被唤醒，满足则执行业务操作，执行完成后唤醒其他线程

public class Demo02pc {
    public static void main(String[] args) {
        Production production = new Production();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.increase();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.decrease();
            }
        },"B").start();
    }
}

class Production{
    private int product=0;
    public synchronized void increase(){
        if (product!=0){        //不满足条件
            //等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //业务操作
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        product++;          //完成生产的业务操作
        System.out.println("生产者为:"+Thread.currentThread().getName());
        //唤醒其他进程
        this.notifyAll();
    }
    public synchronized void decrease(){
        if(product==0){         //不满足条件
            //等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //业务
        product--;          //完成生产的业务操作
        System.out.println("消费者为:"+Thread.currentThread().getName());
        //唤醒
        this.notifyAll();
    }
}

运行后可以成功的模拟

虚拟唤醒问题

但是这只是一个生产者和一个消费者的问题，如果有多个生产者和消费者，用if就会出现问题

因为if只会判断一次

具体这个地方的理解方法，暂时还没有找到很好的解释，自己理解下来就是

        假如有两个生产者AC，两个消费者BD，当此时product为1，而且A和C同时进入增加状态，首先会判断product是否为1，这里product为1，所以线程AC都会进入等待状态，这时如果进入了一个消费者线程，将product减为0，并且唤醒所有等待的线程，因为是if判断，只会判断一次，所以两个生产者线程都会执行业务代码让product++，所以就会出现product为2的情况，这就叫做虚假唤醒。

画个图可以更形象的说明

一开始AC因为有产品，所以都进入了休眠状态等待没有产品的时候出来干活

 这时候来了个线程D，把唯一的一个产品消耗了，然后唤醒了所有的线程A和C，这是A和C都通过了if判断，只不过暂时的“睡着了”，所以他们醒来以后就直接进行了业务操作，两次product++，那可不就是生成了两个产品嘛

 那要怎么解决这个问题呢，其实很简单，在两个进程被唤醒后，再加一道循环不就行了嘛，所以我们这里就可以通过while循环来对进程进行判断，这样就算有两个生产者被唤醒，也只能有一个生产者能进入业务功能，另一个生产者则会通过while循环再次“睡去”

修改后的代码

package com.kuang;

public class Demo02pc {
    public static void main(String[] args) {
        Production production = new Production();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.increase();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.decrease();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.increase();
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.decrease();
            }
        },"D").start();
    }
}

class Production{
    private int product=0;
    public synchronized void increase(){
        if (product!=0){        //改为while循环
            //等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //业务操作
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        product++;          //完成生产的业务操作
        System.out.println("生产者为:"+Thread.currentThread().getName()+"当前产品数量为:"+product);
        //唤醒其他进程
        this.notifyAll();
    }
    public synchronized void decrease(){
        while(product==0){         //改为while循环
            //等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //业务
        product--;          //完成生产的业务操作
        System.out.println("消费者为:"+Thread.currentThread().getName()+"当前产品数量为:"+product);
        //唤醒
        this.notifyAll();
    }
}

Lock锁解决生产者消费者问题

我们通过Lock接口实现的ReentrantLock中有一个方法可以创建一个Condition的对象

 我们进入Condition类,可以看到有一个await方法和signalAll方法

 这两个方法就相当于synchronized锁中的wait和notifyAll方法

 修改后的代码为

package com.kuang;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo02pc {
    public static void main(String[] args) {
        Production production = new Production();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.increase();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.decrease();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.increase();
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                production.decrease();
            }
        },"D").start();
    }
}

class Production{
    private int product=0;
    private Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public void increase(){
        lock.lock();
        try {
            if (product!=0){        //改为while循环
                //等待
                condition.await();
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            product++;          //完成生产的业务操作
            System.out.println("生产者为:"+Thread.currentThread().getName()+"当前产品数量为:"+product);
            //唤醒其他进程
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
        //业务操作

    }
    public void decrease(){
        lock.lock();
        try {
            while(product==0){         //改为while循环
                //等待
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //业务
            product--;          //完成生产的业务操作
            System.out.println("消费者为:"+Thread.currentThread().getName()+"当前产品数量为:"+product);
            //唤醒
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

通过Condition实现精准唤醒

我们知道signalAll是唤醒所有的沉睡进程，signal是随机唤醒队列中第一个进程，那我们有什么班法唤醒指定的进程呢？

        这就需要我们利用Condition来实现精准唤醒

我们可以在一把锁中创建4个Condition对象，然后通过一个计数器判断该唤醒那个进程

代码如下

public class Demo03 {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                data.Print1();
            }

        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                data.Print2();
            }

        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                data.Print3();
            }
        }, "C").start();
    }
}
class Data{
    private int product=0;
    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number=1;
    public void Print1(){
        lock.lock();

        try {
            while(number!=1){
                //等待
                try {
                    condition1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("AAAAAAAAAA");
            number=2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void Print2(){
        lock.lock();
        try {
            while(number!=2){
                //等待
                try {
                    condition2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            number=3;
            System.out.println("BBBBBBBBBBBB");
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void Print3(){
        lock.lock();
        try {
            while(number!=3){
                //等待
                try {
                    condition3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            number=1;
            System.out.println("CCCCCCCCCC");
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}