Notify将只通知处于等待状态的一个线程，而Notify all将通知处于等待状态的所有线程，现在所有被通知的线程和所有被阻塞的线程都有资格获得锁，其中只有一个线程将获得锁，所有其他线程(包括之前处于等待状态的线程)将处于阻塞状态。

摘自Effective Java博客:

The notifyAll method should generally be used in preference to notify. 

If notify is used, great care must be taken to ensure liveness.

所以，我的理解是(从前面提到的博客，“Yann TM”对公认答案和Java文档的评论):

notify() : JVM awakens one of the waiting threads on this object. Thread selection is made arbitrarily without fairness. So same thread can be awakened again and again. So system's state changes but no real progress is made. Thus creating a livelock. notifyAll() : JVM awakens all threads and then all threads race for the lock on this object. Now, CPU scheduler selects a thread which acquires lock on this object. This selection process would be much better than selection by JVM. Thus, ensuring liveness.

notify()让您编写比notifyAll()更有效的代码。

考虑下面这段从多个并行线程执行的代码:

synchronized(this) {
    while(busy) // a loop is necessary here
        wait();
    busy = true;
}
...
synchronized(this) {
    busy = false;
    notifyAll();
}

可以通过使用notify()来提高效率:

synchronized(this) {
    if(busy)   // replaced the loop with a condition which is evaluated only once
        wait();
    busy = true;
}
...
synchronized(this) {
    busy = false;
    notify();
}

在有大量线程的情况下，或者如果等待循环条件的计算成本很高，notify()将比notifyAll()快得多。例如，如果你有1000个线程，那么999个线程将在第一个notifyAll()之后被唤醒和评估，然后是998，然后是997，依此类推。相反，使用notify()解决方案，只会唤醒一个线程。

使用notifyAll()当你需要选择哪个线程将做下一步工作:

synchronized(this) {
    while(idx != last+1)  // wait until it's my turn
        wait();
}
...
synchronized(this) {
    last = idx;
    notifyAll();
}

Finally, it's important to understand that in case of notifyAll(), the code inside synchronized blocks that have been awakened will be executed sequentially, not all at once. Let's say there are three threads waiting in the above example, and the fourth thread calls notifyAll(). All three threads will be awakened but only one will start execution and check the condition of the while loop. If the condition is true, it will call wait() again, and only then the second thread will start executing and will check its while loop condition, and so on.

这里有一个简单的解释:

您是正确的，无论使用notify()还是notifyAll()，直接结果都是恰好有另一个线程获得监视器并开始执行。(假设一些线程实际上在wait()上阻塞了这个对象，其他不相关的线程并没有占用所有可用的内核，等等。)

假设线程A、B和C正在等待这个对象，线程A得到监视器。区别在于当A释放监视器时发生了什么。如果你使用notify()，那么B和C仍然被阻塞在wait()中:它们不是在监视器上等待，而是在等待通知。当A释放监视器时，B和C仍然在那里等待notify()。

如果使用notifyAll()，则B和C都已进入“等待通知”状态，都在等待获取监视器。当A释放监视器时，B或C将获得它(假设没有其他线程竞争该监视器)并开始执行。

我想提一下《Java并发实践》中解释的内容:

第一点，是Notify还是NotifyAll?

It will be NotifyAll, and reason is that it will save from signall hijacking.

If two threads A and B are waiting on different condition predicates of same condition queue and notify is called, then it is upto JVM to which thread JVM will notify. Now if notify was meant for thread A and JVM notified thread B, then thread B will wake up and see that this notification is not useful so it will wait again. And Thread A will never come to know about this missed signal and someone hijacked it's notification. So, calling notifyAll will resolve this issue, but again it will have performance impact as it will notify all threads and all threads will compete for same lock and it will involve context switch and hence load on CPU. But we should care about performance only if it is behaving correctly, if it's behavior itself is not correct then performance is of no use.

这个问题可以通过使用jdk 5中提供的显式锁定Lock的Condition对象来解决，因为它为每个条件谓词提供了不同的等待。在这里，它将表现正确，不会有性能问题，因为它将调用信号，并确保只有一个线程正在等待该条件

注意，对于并发实用程序，您还可以在signal()和signalAll()之间进行选择，因为在那里调用了这些方法。因此，即使使用java.util.concurrent，这个问题仍然有效。

Doug Lea在他著名的书中提出了一个有趣的观点:如果notify()和Thread.interrupt()同时发生，通知实际上可能会丢失。如果可能发生这种情况，并且有显著的影响，notifyAll()是一个更安全的选择，即使您付出了开销的代价(大多数时间唤醒太多线程)。