• 7.JUC线程高级-生产消费问题&虚假唤醒

    描述

    生产消费问题在java多线程的学习中是经常遇到的问题 ，多个线程共享通一个资源的时候会出现各种多线程中经常出现的各种问题。

    实例说明

    三个类：售货员Clerk，工厂Factory，消费者Consumer
    Factory和Consumer共享Clerk对象

    1.普通情况

    1. Clerk类：
    class Clerk{
    //商品数量默认是0,volatile关键字保证内存可见性
    private volatile int product=0;

    //进货，synchronized关键字保证原子性，互斥性
    public synchronized void get(){
        if(product>10){
            System.out.println("货满了");
        }else {
            ++product;
            System.out.println(Thread.currentThread().getName()+"进货"+product);
        }
    }

    //售货
    public synchronized void sale(){
        if(product<=0){
            System.out.println("没货了");
        }else{
            System.out.println(Thread.currentThread().getName()+"卖货"+product);
            --product;
        }
    }
}
    1. Factory类：
    class Factory implements Runnable{

    private Clerk clerk;

    Factory(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for(int i=0;i<20;i++){
        clerk.get();//进货
        }
    }

}
    1. Consumer类：
    class Consumer implements Runnable{

    private Clerk clerk;

    Consumer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            clerk.sale();//卖货
        }

    }        
}

    测试：

    public static void main(String[] args) {

        Clerk clerk = new Clerk();
        Factory factory = new Factory(clerk);
        Consumer consumer = new Consumer(clerk);

        Thread tf = new Thread(factory);
        Thread tc = new Thread(consumer);

        tf.start();
        tc.start();

    }

    输出结果：

    Thread-0进货1
Thread-0进货2
Thread-0进货3
Thread-0进货4
Thread-0进货5
Thread-0进货6
Thread-0进货7
Thread-0进货8
Thread-0进货9
Thread-0进货10
Thread-0进货11
货满了
货满了
货满了
货满了
货满了
货满了
货满了
货满了
货满了
Thread-1卖货11
Thread-1卖货10
Thread-1卖货9
Thread-1卖货8
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2
Thread-1卖货1
没货了
没货了
没货了
没货了
没货了
没货了
没货了
没货了
没货了

    问题出现了，每次进货只有在进货满了的情况下，才会买货，当进货的次数执行完了之后才会执行卖货的方法，而且卖货没货的时候一直输出没货不会等待商家进货。

    1. 重复调用占用资源问题

    原因分析 ：

    上述的情况是当没货的时候还会继续调用该方法，从而占用资源，二货满的情况下也会重复调用进货方法，占用资源，这样是不合理的。

    解决方式：

    当货满了，应该停止进货，释放锁让消费者消费，当没货了应该停止消费释放锁，让进货，这是我们想要的逻辑。
    使用wait()和notifyAll()这两个方法来实现。
    修改Clerk的get和sale方法如下：

    class Clerk{
    //商品数量默认是0
    private volatile int product=0;

    //进货
    public synchronized void get(){
        if(product>10){
            System.out.println("货满了");
            try {
                this.wait();//等待并释放clerk的对象锁，进入线程队列等待被唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            ++product;
            System.out.println(Thread.currentThread().getName()+"进货"+product);
            notifyAll();//唤醒等待的线程
        }
    }

    //售货
    public synchronized void sale(){
        if(product<=0){
            System.out.println("没货了");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName()+"卖货"+product);
            --product;
            notifyAll();
        }
    }
}

    输出测试：

    Thread-0进货1
Thread-1卖货1
没货了
Thread-0进货1
Thread-0进货2
Thread-0进货3
Thread-0进货4
Thread-0进货5
Thread-0进货6
Thread-0进货7
Thread-0进货8
Thread-0进货9
Thread-0进货10
Thread-0进货11
货满了
Thread-1卖货11
Thread-1卖货10
Thread-1卖货9
Thread-1卖货8
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2
Thread-1卖货1
没货了
Thread-0进货1
Thread-0进货2
Thread-0进货3
Thread-0进货4
Thread-0进货5
Thread-0进货6
Thread-0进货7
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2

    这样看起来和谐多了，但是还存在一个小问题，那就是当商品数量变少的时候，而且Factory或者Consumer的run方法内Thread.sleep()方法进行延时，在真是的项目中，这中延时是真实存在的。会产生一方提前结束了，而另外一方没有被唤醒的的情况，从而导致线程一直在等待无法结束的情况产生。

    2. 线程阻塞无法唤醒

    当product比较小假如是1的时候，有可能生产者先循环结束，
    消费者还没结束，一直在waite无法得到唤醒就一直等待
    程序就会停在那里
    解决方式：去掉else，保证每次都会唤醒另外一个线程

    //店员
class Clerk{
    private int product;
    private volatile boolean proFlg=true;//生产者是否完结的标志位
    public boolean isProFlg() {
        return proFlg;
    }

    public void setProFlg(boolean proFlg) {
        this.proFlg = proFlg;
    }
    public synchronized void addProduct(){
        while(product>=10){
            try {
                wait();//大于10各产品，停止生产
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }//else{
            product++;
            System.out.println(Thread.currentThread().getName()+"生产："+product);
            notifyAll();
        //}
    }

    public synchronized void saleProduct(){
        while(product <= 0 && !this.isProFlg()){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//大于10各产品，停止消费
        }//else {
            System.out.println(Thread.currentThread().getName()+"消费："+product);
            product--;
            notifyAll();
        //}
    }

}

    3.虚假唤醒问题

    Clerk clerk = new Clerk();
        Factory factory = new Factory(clerk);
        Consumer consumer = new Consumer(clerk);

        Thread tf = new Thread(factory);
        Thread tc = new Thread(consumer);
        Thread tc2 = new Thread(consumer);
        tf.start();
        tc.start();
        tc2.start();

    输出结果：

    没货了
没货了
Thread-0进货1
Thread-2卖货1
没货了
Thread-1卖货0
没货了
Thread-2卖货-1
没货了
Thread-1卖货-2
没货了
Thread-2卖货-3
没货了
Thread-1卖货-4
没货了
Thread-2卖货-5
没货了
Thread-1卖货-6

    当只有一个Factory有两个Consumer的时候就会出现虚假唤醒问题。导致商品都成了负数了。

    原因分析：

    当创建对个生产消费者线程的时候，会产生虚假唤醒，导致product
    为负数，是因为当消费者线程A发现没货的时候，wait之后释放锁，另外一个
    消费者线程B获得锁开始执行，结果也没货，开始wait，当生产者生产之后
    notifyAll，A，B线程开始继续向下执行，结果进行了两次–操作，导致
    product成为了负数

    解决方式：

    JDK文档object的wait方法已经考虑到这种情况，防止虚假唤醒，应该放在循环中，多次进行检查，直到满足条件才进行下一步

    class Clerk{
    //商品数量默认是0
    private volatile int product=0;

    //进货
    public synchronized void get(){
        while(product>10){
            System.out.println("货满了");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            ++product;
            System.out.println(Thread.currentThread().getName()+"进货"+product);
            notifyAll();

    }

    //售货
    public synchronized void sale(){
        while(product<=0){
            System.out.println("没货了");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            System.out.println(Thread.currentThread().getName()+"卖货"+product);
            --product;
            notifyAll();

    }
}

    4. 守护线程解决线程阻塞

    上面解决了虚假唤醒问题，但是当多个消费者和一个生产者的时候，生产者有可能先结束循环，但是消费者还没结束，结果到了其他消费者的时候发现product是小于0的于是就wait，程序一直等待得不到结束，就会一直在wait()

    解决方式：

    在共享资源clerk类中定义生产者线程标志位，在main线程中创建一个线程设置为守护线程
    并启动，在该守护线程中创建匿名内部类Runnable并在run方法中判断生产者线程isAlive()
    如果生产者线程结束，就把标志位置为false，该标识位和消费者线程的while判断条件中串联
    当生产者线程为false的之后短路，使得消费者线程啥都不做，直到线程结束。

    1. Clerk中设置Factory线程的标志位
    private boolean facctoryFlg = true;//工厂线程结束的标志位，为false表示线程执行完毕
    public boolean isFacctoryFlg() {
        return facctoryFlg;
    }

    public void setFacctoryFlg(boolean facctoryFlg) {
        this.facctoryFlg = facctoryFlg;
    }
    1. 主方法中创建守护线程
    //创建守护线程
        Thread daemon = new Thread(new Runnable() {
            @Override
            public void run() {
               while(true){
                  if(!tf.isAlive()){
                      clerk.setFacctoryFlg(false);
                      System.out.println("factory--------------"+tf.isAlive());
                      break;
                  }
               }
            }
        });
        daemon.setDaemon(true);//设置为守护线程(后台线程)
        daemon.start();
    1. 修改Clerk的sale方法：
    //售货
    public synchronized void sale(){

        while(product<=0){
            //当Factory线程结束的时候，直接结束sale方法
            if(!isFacctoryFlg()){
                return;
            }
            System.out.println("没货了");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            System.out.println(Thread.currentThread().getName()+"卖货"+product);
            --product;
            notifyAll();
        }

    通过守护线程daemon的监视，可以避免线程阻塞的情况，就算有多个消费者或者Factory只要在守护线程中添加判断逻辑，就可以避免阻塞的出现。
  • 相关阅读:
    atom 安装插件列表
    django学习
    windows 安装 python3
    python3 监控代码变化 自动重启 提高开发效率
    git无法pull仓库refusing to merge unrelated histories
    python 项目部署virtualenv
    python 多线程并发threading & 任务队列Queue
    python logging 日志使用
    jupyter 教程
    mysql 替换数据库字段内容
  • 原文地址：https://www.cnblogs.com/twodog/p/12136080.html
Copyright © 2020-2023  润新知