notify()和notifyAll()的本质区别

港控/mmm° 2022-03-09 13:14 209阅读 0赞

## notify()和notifyAll()的本质区别 ##

**notify()和notifyAll(**)都是Object对象用于通知处在等待该对象的线程的方法。两者的最大区别在于：

*  notifyAll使所有**原来在该对象上等待**被notify的**所有线程统统退出wait的状态**，变成**等待该对象上的锁**，**一旦该对象被解锁**，他们就会去**竞争**。
 *  notify则文明得多，它只是选择一个wait状态线程进行通知，并使它获得该对象上的锁，但不惊动其他同样在等待被该对象notify的线程们，当第一个线程运行完毕以后释放对象上的锁此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，继续处在wait状态，直到这个对象发出一个notify或notifyAll，它们等待的是被notify或notifyAll，而不是锁。

下面是一个很好的例子：

public class NotifyTest {
        private String flag[] = { "true" };
    
        class NotifyThread extends Thread {
            public NotifyThread(String name) {
                super(name);
            }
    
            public void run() {
                try {
                    sleep(3000);// 推迟3秒钟通知
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                synchronized (flag) {
                    flag[0] = "false";
                    flag.notifyAll();
                }
            }
        };
    
        class WaitThread extends Thread {
            public WaitThread(String name) {
                super(name);
            }
    
            public void run() {
                System.out.println(getName() + "  flag:" + flag);
                synchronized (flag) {
                    System.out.println(getName() + "  flag:" + flag);
                    while (!flag[0].equals("false")) {
                        System.out.println(getName() + " begin waiting!");
                        long waitTime = System.currentTimeMillis();
                        try {
                            flag.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        waitTime = System.currentTimeMillis() - waitTime;
                        System.out.println("wait time :" + waitTime);
                    }
                    System.out.println(getName() + " end waiting!");
                }
                System.out.println(getName() + " end waiting!");
    
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            System.out.println("Main Thread Run!");
            NotifyTest test = new NotifyTest();
            NotifyThread notifyThread = test.new NotifyThread("notify01");
            WaitThread waitThread01 = test.new WaitThread("waiter01");
            WaitThread waitThread02 = test.new WaitThread("waiter02");
            WaitThread waitThread03 = test.new WaitThread("waiter03");
            notifyThread.start();
            waitThread01.start();
            waitThread02.start();
            waitThread03.start();
        }
    }

结果：

Main Thread Run!
    waiter01  flag:[Ljava.lang.String;@584aceca
    waiter01  flag:[Ljava.lang.String;@584aceca
    waiter02  flag:[Ljava.lang.String;@584aceca
    waiter01 begin waiting!
    waiter02  flag:[Ljava.lang.String;@584aceca
    waiter02 begin waiting!
    waiter03  flag:[Ljava.lang.String;@584aceca
    waiter03  flag:[Ljava.lang.String;@584aceca
    waiter03 begin waiting!
    wait time :3000
    waiter03 end waiting!
    waiter03 end waiting!
    wait time :3001
    waiter02 end waiting!
    waiter02 end waiting!
    wait time :3001
    waiter01 end waiting!
    waiter01 end waiting!

**继续看下面的例子：**

public class ProduceConsumerVersion2 {
    
        private int i = 0;
    
        final private Object LOCK = new Object();
    
        private volatile boolean isProduced = false;
    
        public void produce() {
            synchronized (LOCK) {
                if (isProduced) {
                    try {
                        LOCK.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    i++;
                    System.out.println("P->" + i);
                    LOCK.notify();
                    isProduced = true;
                }
            }
        }
    
        public void consume() {
            synchronized (LOCK) {
                if (isProduced) {
                    System.out.println("C->" + i);
                    LOCK.notify();
                    isProduced = false;
                } else {
                    try {
                        LOCK.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        public static void main(String[] args) {
            ProduceConsumerVersion2 pc = new ProduceConsumerVersion2();
            Stream.of("P1", "P2").forEach(n ->
                    new Thread(n) {
                        @Override
                        public void run() {
                            while (true)
                                pc.produce();
                        }
                    }.start()
            );
            Stream.of("C1", "C2").forEach(n ->
                    new Thread(n) {
                        @Override
                        public void run() {
                            while (true)
                                pc.consume();
                        }
                    }.start()
            );
        }
    }

输出：  
![在这里插入图片描述][20190313113243488.png]  
分析上述输出：为什么不会一直生产/消息下去呢？P1生产后，进入wait状态，C1被唤醒，进行消费后，进入wait状态，P2被唤醒，进行生产后，进入wait状态，C2被唤醒，进行消费后，进入wait状态，去唤醒C1，C1发现没有可消费的数据，又进入wait状态。现在所有的线程（P1,P2,C1,C2）都进入了wait状态，且不会有线程去notify了。这就是使用notify的弊端，可以使用nofityAll解决此问题。

[20190313113243488.png]: /images/20220309/39d8bc7f522d4a2ca48ddd42865d41e8.png