notify,notifyAll区别（生产者消费者案例）

最新推荐文章于 2021-04-19 09:38:07 发布

OkidoGreen

最新推荐文章于 2021-04-19 09:38:07 发布

阅读量1.2k

点赞数

分类专栏： Java并发-锁 Java并发-多线程实践

原文链接：https://blog.csdn.net/liuzhixiong_521/article/details/86677057

版权

Java并发-多线程实践同时被 2 个专栏收录

52 篇文章 4 订阅

订阅专栏

Java并发-锁

18 篇文章 0 订阅

订阅专栏

1.代码示例

1.1 生产者

package com.example.hxk.thread.demo;

import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @author Smith 2019/3/21
 */
public class Producer implements Runnable{

    List<Integer> cache;

    public void put() throws InterruptedException {
        synchronized (cache) {
            while (cache.size() == 1) {
                try {
                    cache.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

            TimeUnit.SECONDS.sleep(1);

            cache.add(1);
            System.out.println(Thread.currentThread().getName() + "生产者生产了一条。");
            cache.notify();
        }
    }

    public Producer(List<Integer> cache) {
        this.cache = cache;
    }

    @Override
    public void run() {
        while (true) {
            try {
                put();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

1.2 消费者

package com.example.hxk.thread.demo;

import java.util.List;

/**
 * @author Smith 2019/3/21
 */
public class Customer implements Runnable {

    List<Integer> cache;

    public Customer(List<Integer> cache) {
        this.cache = cache;
    }

    private void custom() {
        synchronized (cache) {
            while (cache.size() == 0) {
                try {
                    cache.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            cache.remove(0);
            System.out.println(Thread.currentThread().getName() + "消费者消费了一条。");
            cache.notify();
        }
    }
    @Override
    public void run() {
        while (true) {
            custom();
        }
    }
}

1.3 测试代码

1.3.1 一个生产者一个消费者

package com.example.hxk.thread.demo;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Smith 2019/3/21
 */
public class Test {

    public static void main(String[] args) {

        List<Integer> cache = new ArrayList<>();
        new Thread(new Producer(cache), "P1").start();
        new Thread(new Customer(cache), "C1").start();
    }
}

运行结果：

结论：

使用notify且一个生产者一个消费者的情况下，生产和消费有条不紊的运行，没有任何问题。

1.3.2 一个生产者两个消费者

package com.example.hxk.thread.demo;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Smith 2019/3/21
 */
public class Test {

    public static void main(String[] args) {

        List<Integer> cache = new ArrayList<>();

        new Thread(new Producer(cache), "P1").start();
        new Thread(new Customer(cache), "C1").start();
        new Thread(new Customer(cache), "C2").start();
    }
}

复制代码

运行结果：

结论：

使用notify且一个生产者两个消费者的情况下，生产了两次后，程序死锁了。

1.3.3 将Producer和Customer中的notify()换成notifyAll()

代码就不粘了。

运行结果

程序又恢复了正常。

2.notify()和notifyAll的区别

每个同步对象都有自己的锁池和等待池。

2.1 锁池和等待池

锁池：假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
等待池：假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。如果另外的一个线程调用了相同对象的notifyAll()方法，那么处于该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。如果另外的一个线程调用了相同对象的notify()方法，那么仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池.

2.2 notify()和notifyAll()的区别

线程调用了wait()方法，便会释放锁，并进入等待池中，不会参与锁的竞争
调用notify()后，等待池中的某个线程(只会有一个)会进入该对象的锁池中参与锁的竞争，若竞争成功，获得锁，竞争失败，继续留在锁池中等待下一次锁的竞争。
调用notifyAll()后，等待池中的所有线程都会进入该对象的锁池中参与锁的竞争。

3.例子解析

知道了2的知识后，上面的三个例子也就好解释了。

1.3.1：因为只有一个生产者和消费者，所以等待池中始终只有一个线程，要么就是生产者唤醒消费者，要么消费者唤醒生产者，所以程序可以成功跑起来；

1.3.2：举个可能的例子

现在有三个线程，生产者P1, 消费者C1和C2.开始运行的时候，三个都在锁池中等待竞争，假设C1抢到锁了，C1执行时由于没有资源可以消费调用wait()方法，释放锁并进入等待池。
C2抢到了锁，开始消费，同理，C2也进入了等待池。现在锁池里面只剩下了P1.
P1获得了锁，开始生产，生产完成后，P1开始调用notify()方法唤醒等待池中的C1或者C2，然后P1调用wait()方法释放锁，并进入了等待池。
假设唤醒的是C1，C1进入锁池并获得锁，消费后notify()方法唤醒了C2,C2进入锁池，C1进入等待池，现在锁池中只有C1。
C1获得了锁，发现没有任何资源可以消费，wait()后释放了锁，进入了等待池，现在三个线程全都在等待池，锁池中没有任何线程。导致死锁！

1.3.3: notifyAll()后，不存在只唤醒同类线程的情况，故也就不会出现1.3.2死锁的情况。

引用

作者：emailed 来源：CSDN 原文：blog.csdn.net/emailed/art…
作者：泡芙掠夺者来源：简书原文：www.jianshu.com/p/45626f4e0…

区别
notify：只会唤醒等待该锁的其中一个线程。
notifyAll：唤醒等待该锁的所有线程。
既然notify会唤醒一个线程，并获取锁，notifyAll会唤醒所有线程并根据算法选取其中一个线程获取锁，那最终结果不都是只有一个线程获取锁吗？那JDK为什么还需要做出来这两个方法呢？这两种同步方法本质上会有什么区别？

这还要从对象内部锁的调度说起。

对象内部锁
其实，每个对象都拥有两个池，分别为锁池(EntrySet)和(WaitSet)等待池。

锁池：假如已经有线程A获取到了锁，这时候又有线程B需要获取这把锁(比如需要调用synchronized修饰的方法或者需要执行synchronized修饰的代码块)，由于该锁已经被占用，所以线程B只能等待这把锁，这时候线程B将会进入这把锁的锁池。
等待池：假设线程A获取到锁之后，由于一些条件的不满足(例如生产者消费者模式中生产者获取到锁，然后判断队列为满)，此时需要调用对象锁的wait方法，那么线程A将放弃这把锁，并进入这把锁的等待池。
如果有其他线程调用了锁的notify方法，则会根据一定的算法从等待池中选取一个线程，将此线程放入锁池。
如果有其他线程调用了锁的notifyAll方法，则会将等待池中所有线程全部放入锁池，并争抢锁。

锁池与等待池的区别：等待池中的线程不能获取锁，而是需要被唤醒进入锁池，才有获取到锁的机会。

问题复现
那么使用notify和notifyAll到底会有什么区别呢？
请看下面一组生产者消费者的例子。
有两个生产者t1和t2，两个消费者t3和t4，以及一个长度为1的队列。