只有当同时存在notify()时，wait()才有意义，因此它总是关于线程之间的通信，并且需要同步才能正确工作。有人可能会说，这应该是隐含的，但这并没有真正的帮助，原因如下:

从语义上讲，您永远不会只是等待()。你需要一些条件来满足，如果没有，你就等待，直到它满足。所以你真正要做的是

if(!condition){
    wait();
}

但是这个条件是由一个单独的线程设置的，所以为了让它正确工作，你需要同步。

它还有一些错误的地方，仅仅因为你的线程退出等待并不意味着你正在寻找的条件是真的:

您可能会得到虚假的唤醒(意味着线程可以在没有收到通知的情况下从等待中唤醒)，或者 可以设置条件，但是第三个线程在等待线程醒来(并重新获取监视器)时将条件再次设为false。

要处理这些情况，你真正需要的是:

synchronized(lock){
    while(!condition){
        lock.wait();
    }
}

更好的是，完全不要乱动同步原语，而是使用java.util.concurrent包中提供的抽象。

如果可以在同步块之外调用wait()，保留它的语义——挂起调用者线程，那么潜在的损害是什么?

让我们用一个具体的例子来说明如果可以在同步块之外调用wait()会遇到什么问题。

假设我们要实现一个阻塞队列(我知道，API中已经有一个了:)

第一次尝试(没有同步)可能如下所示

class BlockingQueue {
    Queue<String> buffer = new LinkedList<String>();

    public void give(String data) {
        buffer.add(data);
        notify();                   // Since someone may be waiting in take!
    }

    public String take() throws InterruptedException {
        while (buffer.isEmpty())    // don't use "if" due to spurious wakeups.
            wait();
        return buffer.remove();
    }
}

这是可能发生的事情:

消费者线程调用take()并看到buffer.isEmpty()。 在消费者线程继续调用wait()之前，一个生产者线程出现并调用一个完整的give()，即buffer.add(data);notify (); 消费者线程现在将调用wait()(并错过刚刚调用的notify())。 如果不走运，生产者线程将不会产生更多的give()，因为消费者线程从未被唤醒，我们有一个死锁。

一旦您理解了这个问题，解决方案是显而易见的:使用synchronized来确保在isEmpty和wait之间永远不会调用notify。

不详细说明:这个同步问题是普遍存在的。正如Michael Borgwardt所指出的，wait/notify完全是关于线程之间的通信，所以您最终总是会得到类似于上面描述的竞争条件。这就是为什么强制执行“只在synchronized内部等待”规则的原因。

@Willie发布的一段链接很好地总结了这一点:

您需要绝对保证侍者和通知者就谓词的状态达成一致。服务员在稍微在进入睡眠之前的某个时间点检查谓词的状态，但它的正确性取决于谓词在进入睡眠时为真。在这两个事件之间有一段时间的漏洞，这可能会破坏程序。

生产者和消费者需要达成一致的谓词在上面的例子buffer.isEmpty()中。通过确保在同步块中执行等待和通知来解决协议。

这篇文章已经被改写为一篇文章:Java:为什么等待必须在同步块中调用

直接从这个Java oracle教程:

当线程调用d.wait时，它必须拥有d -的内在锁 否则抛出错误。在synchronized中调用等待 方法是一种获取内在锁的简单方法。

@Rollerball是对的。调用wait()，以便线程可以等待某些条件的发生，当wait()调用发生时，线程被迫放弃它的锁。 要放弃一些东西，你需要先拥有它。线程首先需要拥有锁。 因此需要在同步方法/块中调用它。

是的，我同意上面所有关于潜在损害/不一致的答案，如果你没有检查同步方法/块中的条件。然而，正如@shrini1000所指出的，只是在同步块中调用wait()并不能避免这种不一致的发生。

这是一篇不错的文章。

这基本上与硬件架构(即RAM和缓存)有关。

如果你没有将synchronized与wait()或notify()一起使用，另一个线程可能会进入同一个块，而不是等待监视器进入它。此外，当访问一个没有同步块的数组时，另一个线程可能看不到它的变化…实际上，当另一个线程已经在处理CPU内核的x级缓存(也就是1 /2 /3级缓存)中有一个数组的副本时，它不会看到对它的任何更改。

但是同步块只是奖章的一面:如果您实际上从非同步上下文中访问同步上下文中的对象，即使在同步块中，该对象仍然不会被同步，因为它在其缓存中保存了对象的自己副本。我在这里写了这个问题:https://stackoverflow.com/a/21462631和当一个锁持有一个非final对象时，对象的引用仍然可以被另一个线程改变吗?

此外，我确信x级缓存要对大多数不可重现的运行时错误负责。这是因为开发人员通常不了解底层的东西，比如CPU如何工作或内存层次结构如何影响应用程序的运行:http://en.wikipedia.org/wiki/Memory_hierarchy

为什么编程类不首先从内存层次结构和CPU架构开始，这仍然是一个谜。“Hello world”在这里没用。；）

如果在wait()之前没有同步，可能会导致如下问题:

If the 1st thread goes into makeChangeOnX() and checks the while condition, and it is true (x.metCondition() returns false, means x.condition is false) so it will get inside it. Then just before the wait() method, another thread goes to setConditionToTrue() and sets the x.condition to true and notifyAll(). Then only after that, the 1st thread will enter his wait() method (not affected by the notifyAll() that happened few moments before). In this case, the 1st thread will stay waiting for another thread to perform setConditionToTrue(), but that might not happen again.

但是如果你把synchronized放在改变对象状态的方法之前，这就不会发生。

class A {

    private Object X;

    makeChangeOnX(){
        while (! x.getCondition()){
            wait();
            }
        // Do the change
    }

    setConditionToTrue(){
        x.condition = true; 
        notifyAll();

    }
    setConditionToFalse(){
        x.condition = false;
        notifyAll();
    }
    bool getCondition(){
        return x.condition;
    }
}

当您在对象t上调用notify()时，Java会通知特定的t.wait()方法。但是，Java如何搜索并通知特定的等待方法呢?

Java只查看被对象t锁定的同步代码块。Java不能搜索整个代码来通知特定的t.wait()。

我们都知道wait()， notify()和notifyAll()方法用于线程间 通信。为摆脱误信号和伪唤醒问题，等待线程 总是等待一些条件。 例如,

boolean wasNotified = false;
while(!wasNotified) {
    wait();
}

然后通知线程集wasNotified变量为true和notify。

每个线程都有自己的本地缓存，所以所有的更改都先写在那里 然后逐步提升到主存。

是否这些方法没有在同步块中调用，wasNotified变量 不会被刷新到主内存中，而是在线程的本地缓存中 因此，等待线程将继续等待信号，尽管它已通过通知重置 线程。

为了修复这些类型的问题，这些方法总是在同步块中调用 这确保当同步块开始时，那么一切将从主读取 内存，并将在退出同步块之前被刷新到主内存。

synchronized(monitor) {
    boolean wasNotified = false;
    while(!wasNotified) {
        wait();
    }
}

谢谢，希望它能澄清。

根据文档:

当前线程必须拥有该对象的监视器。线程释放 这个监视器的所有权。

Wait()方法仅仅意味着它释放对象上的锁。因此，对象只在同步块/方法中被锁定。如果线程在同步块之外意味着它没有被锁定，如果它没有被锁定那么你会释放对象上的什么?

Thread wait on the monitoring object (object used by synchronization block), There can be n number of monitoring object in whole journey of a single thread. If Thread wait outside the synchronization block then there is no monitoring object and also other thread notify to access for the monitoring object, so how would the thread outside the synchronization block would know that it has been notified. This is also one of the reason that wait(), notify() and notifyAll() are in object class rather than thread class.

基本上监视对象在这里是所有线程的公共资源，监视对象只能在同步块中可用。

class A {
   int a = 0;
  //something......
  public void add() {
   synchronization(this) {
      //this is your monitoring object and thread has to wait to gain lock on **this**
       }
  }