Java生产消费问题与虚假唤醒(spurious wakeup)

参考并发容器-阻塞队列 第四部分“阻塞队列的实现原理”。
参考代码生产者-消费者

1.缺少wait会出现的问题

三个类:售货员Clerk,工厂Factory,消费者Consumer
Factory和Consumer共享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;
        }
    }
}
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();//进货
        }
    }
}
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
没货了
没货了
没货了
没货了
没货了
没货了
没货了
没货了
没货了
  • 问题:上述的情况是当没货的时候还会继续调用该方法,从而占用资源,二货满的情况下也会重复调用进货方法,占用资源,这样是不合理的。
  • 解决方式:当货满了,应该停止进货,释放锁让消费者消费,当没货了应该停止消费释放锁,让进货,这是我们想要的逻辑。
    使用wait()和notifyAll()这两个方法来实现。
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-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-0进货8
Thread-1卖货8
Thread-1卖货7
Thread-1卖货6
Thread-1卖货5
Thread-1卖货4
Thread-1卖货3
Thread-1卖货2
Thread-1卖货1

2.线程阻塞无法唤醒

  • 当产品为1时,生成者线程生产结束;此时Consumer还处于wait无法得到唤醒。
    这种情景对吗?这种问题什么情况下会发生?
  • 解决方式:去掉else,每次都会唤醒另外一方的线程。
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();
            }
        }
        ++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();
            }
        }
         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
  • 原因
    两个消费者都处于wait状态,然后生产者生产了一个notifyAll,两个消费者同时往下执行,导致product为负数。
  • 解决方法:防止虚假唤醒,应该放在循环中,多次进行检查,直到满足条件才进行下一步

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

  • 当多个消费者和一个生产者的时候,生产者有可能先结束循环,但是消费者还没结束,结果到了其他消费者的时候发现product是小于0的于是就wait,程序一直等待得不到结束,就会一直在wait()
  • 解决方式
    在共享资源clerk类中定义生产者线程标志位,在main线程中创建一个线程设置为守护线程 并启动,在该守护线程中创建匿名内部类Runnable,并在run方法中判断生产者线程isAlive() 。如果生产者线程结束,就把标志位置为false,该标识位和消费者线程的while判断条件中串联,当生产者线程为false的之后短路,使得消费和线程啥都不做,直到线程结束。
  • Clerk中设置Factory 线程标志位
    private boolean facctoryFlg = true;//工厂线程结束的标志位,为false表示线程执行完毕
    public boolean isFacctoryFlg() {
        return facctoryFlg;
    }

    public void setFacctoryFlg(boolean facctoryFlg) {
        this.facctoryFlg = facctoryFlg;
    }
  • Main中创建守护线程
        //创建守护线程
        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();
  • 修改·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();
    }

参考

  • 1)生产消费问题&虚假唤醒

你可能感兴趣的:(Java生产消费问题与虚假唤醒(spurious wakeup))