同步块后面(Behind Synchronized Block)

 在多线程中工作时，Java中的同步块是一个很好的功能，这很常见。 我知道它们的工作原理大多数，但是想要在结合wait和notify（All）时更加确定它们是如何工作的。 
 
 通常，当一个线程进入一个同步块时，除非第一个线程已经离开，否则其他线程不能进入该块。 但是，在调用同步对象的等待时，情况并非如此。 如果是这样，另一个线程将无法调用notify（All），这需要在调用之前与对象同步。 
 
 呼叫等待是否会使呼叫脱离同步？ 或者，如果Java在不同的块中发现通知（全部），它只会发出异常？ 另外，当从一个同步块调用wait然后从另一个同步块通知（All）时，一个线程在继续之前是否等待另一个线程完成，如果是，那么哪一个？ 
 
 现在我可以设置一个快速测试来回答大部分问题，我知道。 但它不会回答更技术性的东西，我相信这里有人可以。 我不只是对什么和什么时候感兴趣，而且也是为什么。 尝试搜索一些记录的信息，但找不到有关wait / notify（All）的任何有用信息。 
 
 编辑： 
 
 如果其他人应该感兴趣，这是测试结果。 如果我们有Thread1，Thread2和Thread3，前两个等待释放，第三个是释放它们，那么顺序就是这样。 
 
 
 
 线程1进入并调用wait（） 
 
 
 线程2进入并调用wait（） 
 
 
 Thread3进入并调用notifyAll（） 
 
 
 Thread3总是完成 
 
 
 等待的线程却没有特定的顺序。 首先执行哪一个是完全随机的，与他们调用wait（）的顺序无关。 但是，调用notify（All）的线程将始终在任何等待线程继续之前完成。 
 

Synchronized blocks in Java is a great feature when working in multiple threads, which is pretty often. I know most of how they work, but would like to be more sure of how they work when combined with wait and notify(All). 
 
Normally when one thread enters an synchronized block, no other thread can enter this block until the first thread has left. This however is not the case when calling wait on the synchronized object. If it did, another thread would not be able to call notify(All), which requires synchronization with the object before it is called. 
 
So does the call to wait take the call out of the synchronization? Or does java just make an exception if it finds notify(All) within a different block? Also when calling wait from one synchronized block and then notify(All) from another, does one thread wait for the other to finish before continuing, if so, which one? 
 
Now I could setup a quick test to answer most of this, that I am aware of. But it is not going to answer the more technical stuff, which I am sure that someone here can. I am not just interested in the what and when, but also the why. Tried searching for some documented info, but could not find anything useful about wait/notify(All). 
 
EDIT:
 
If others should be interested, this is the test result. If we have Thread1, Thread2 and Thread3 where the first two waits to be release and the third is the one to release them, the order will go like this. 
 
 
 
Thread1 enters and calls wait()
 
 
Thread2 enters and calls wait()
 
 
Thread3 enters and calls notifyAll()
 
 
Thread3 finishes, always
 
 
The waiting threads however has no specific order. Which one is executed first, is completly random and has nothing to do with the order in which they called wait(). The thread calling notify(All) however will always finish before any waiting threads continues. 
 

原文：https://stackoverflow.com/questions/33801573