notify和notifyAll的区别

1、我们先验证下wait可以用notify和notifyAll来唤醒

如下测试代码：

public class WaitSleepDemo {

    public static void main(String[] args) {
        final  Object lock = new Object();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread A is waiting to get lock");
                synchronized (lock){

                    try {
                        System.out.println("thread A get lock");
                        Thread.sleep(20);
                        System.out.println("thread A do wait method");
                        //无限期的等待
                        lock.wait();
                        //Thread.sleep(1000);
                        System.out.println("thread A is done");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();


        //为了让Thread A 先于Thread B执行
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread B is waiting to get lock");
                synchronized (lock){
                    try {
                        System.out.println("thread B get lock");
                        System.out.println("thread B is sleeping 10 ms");
                       Thread.sleep(10);
                       // lock.wait(10);
                        System.out.println("thread B is done");
                        //这句注释掉，thread A is done就不会被打印
                        lock.notify(); // lock.notifyAll();
                       

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        }).start();
    }
}

　　

　　执行结果：

thread A is waiting to get lock
thread A get lock
thread B is waiting to get lock
thread A do wait method
thread B get lock
thread B is sleeping 10 ms
thread B is done
thread A is done

　　

 

2、notify和notifAll的区别

两个概念

锁池EntryList

等待池 WaitSet

 

锁池：

假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B,C想要调用这个对象的某个某个synchronized方法(或者块)之前必须获得该对象锁的拥有权，而恰巧该对象的锁目前正被A所占有，此时B， C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。

等待池

   假设线程A调用了某个对象的wait方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入等待池中的线程不会去竞争该对象的锁。

 notify和notifAll的区别

notifyAll： 会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会

notify： 只会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会。

 

 

如下的测试代码

public class NotificationDemo {
    private volatile boolean go = false;


    private synchronized  void shouldGo() throws InterruptedException {

        while (go != true){
            System.out.println(Thread.currentThread() + " is going to wait on this object");
            wait();
            System.out.println(Thread.currentThread() + " is woken up");

        }
        go = false; //reseting condition
    }


    private synchronized  void go() throws InterruptedException {

        while (go == false){
            System.out.println(Thread.currentThread() + " is going to notify all or one ");
            go = true;

            notify();
        }

    }



    public static void main(String[] args) throws InterruptedException {

        NotificationDemo test = new NotificationDemo();

          Runnable waitTak = new Runnable() {
            @Override
            public void run() {
                try {
                    test.shouldGo();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " finish execution");
            }
        };

         Runnable notifyTask = new Runnable() {
            @Override
            public void run() {
                try {
                    test.go();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " finish execution");
            }
        };

        Thread t1 = new Thread(waitTak, "WT1");
        Thread t2 = new Thread(waitTak, "WT2");
        Thread t3 = new Thread(waitTak, "WT3");
        t1.start();
        t2.start();
        t3.start();

        Thread t4 = new Thread(notifyTask, "NT1");
        Thread.sleep(200);
        t4.start();


    }
}

　　打印结果：

Thread[WT1,5,main] is going to wait on this object
Thread[WT2,5,main] is going to wait on this object
Thread[WT3,5,main] is going to wait on this object
Thread[NT1,5,main] is going to notify all or one 
Thread[WT1,5,main] is woken up
NT1 finish execution
WT1 finish execution

　　多执行几次，可以发现notify调用后，被唤醒的线程是随机的。

 

将notify改成notifyAll

 

 打印结果如下：

Thread[WT1,5,main] is going to wait on this object
Thread[WT3,5,main] is going to wait on this object
Thread[WT2,5,main] is going to wait on this object
Thread[NT1,5,main] is going to notify all or one 
Thread[WT2,5,main] is woken up
Thread[WT3,5,main] is woken up
Thread[WT3,5,main] is going to wait on this object
NT1 finish execution
Thread[WT1,5,main] is woken up
Thread[WT1,5,main] is going to wait on this object
WT2 finish execution

　　说明三个线程都被唤醒了