Кто-нибудь может объяснить нить мониторов и ждать?

Много хороших ответов здесь уже. Но просто хочу упомянуть здесь, что другой ДОЛЖЕН СДЕЛАТЬ, когда использование ожидает (), должен сделать это в цикле, зависящем от условия, Вы ожидаете того, в случае, если Вы видите побочные пробуждения, которые, по моему опыту, происходят.

Для ожидания некоторого другого потока, чтобы изменить условие на истинный и уведомить:

synchronized(o) {
  while(! checkCondition()) {
    o.wait();
  }
}

, Конечно, в эти дни, я рекомендовал бы просто использовать новый объект Условия, поскольку это более ясно и имеет больше функций (как разрешение нескольких условий на блокировку, способность проверить ожидают длина очереди, более гибкое расписание/прерывание, и т.д.).

 Lock lock = new ReentrantLock();
 Condition condition = lock.newCondition();
 lock.lock();
 try {
   while (! checkCondition()) {
     condition.await();
   }
 } finally {
   lock.unlock();
 }

}

Ожидайте бросает монитор, таким образом, у Вас должен быть он для отказа от него. Уведомьте должен иметь монитор также.

главная причина, почему Вы хотите сделать, это должно гарантировать, чтобы у Вас был монитор, когда Вы возвращаетесь из ожидания () - обычно, Вы используете ожидать/уведомлять протокол для защиты некоторого совместно используемого ресурса, и Вы хотите, чтобы он был безопасен коснуться его, когда ожидают возвраты. То же с уведомляет - обычно, что Вы изменяете что-то и затем звоните, уведомляют () - что Вы хотите иметь монитор, внести изменения, и вызов уведомляет ().

, Если Вы сделали функцию как это:

public void synchWait() {
   syncronized { wait(); }
}

у Вас не было бы монитора, когда ожидают, возвратился - Вы могли получить его, но Вы не могли бы получить его затем.

Вот мое понимание того, почему ограничение является на самом деле требованием. Я основываю это на реализации монитора C++, которую я сделал некоторое время назад путем объединения взаимного исключения и условной переменной.

В система mutex+condition_variable=monitor , эти ожидают , вызов устанавливает условную переменную в состояние ожидания и выпускает взаимное исключение. Условная переменная является общим состоянием, таким образом, это должно быть заблокировано для предотвращения условий состязания между потоками, которые хотят ожидать и потоки, которые хотят уведомить. Вместо того, чтобы представить еще одно взаимное исключение для блокировки его состояния используется существующее взаимное исключение. В Java правильно заблокировано взаимное исключение, когда поток about-to-wait владеет монитором.

Это должно владеть монитором, так как цель ожидания () состоит в том, чтобы выпустить монитор и позволить другим потокам получить монитор, чтобы сделать собственную обработку. Цель этих методов (ожидает/уведомляет), должен скоординировать доступ к синхронизируемым блокам кода между двумя потоками, которые требуют друг друга для выполнения некоторой функциональности. Это не просто вопрос доступа проверки к структуре данных, ориентировано на многопотоковое исполнение, но скоординировать события между несколькими потоками.

классическим примером А был бы случай производителя/потребителя, где один поток продвигает данные очереди, и другой поток использует данные. Поток потребления всегда требовал бы, чтобы монитор получил доступ к очереди, но выпустит монитор, как только очередь пуста. Поток производителя тогда только заставил бы доступ писать в поток, когда потребитель больше не обрабатывает. Это уведомило бы потребительский поток, как только это продвинуло больше данных в очередь, таким образом, это может возвратить монитор и получить доступ к очереди снова.

В основном ожидание выполняется, если есть условие, что очередь пуста.

If(queue is empty)
     queue.wait();

Предположим, очередь пуста. В случае, если текущий поток прерывается после проверки очереди, то если другой поток добавляет несколько элементов в очередь, текущий поток не будет знать и будет ждать государство. Это неверно. Итак, у нас должно получиться что-то вроде

Synchornized(queue)
{
   if(queue is empty)
          queue.wait();
}

. Теперь давайте рассмотрим, что, если бы они заставили себя ждать как синхронизированные. Как уже упоминалось в одном из комментариев, он снимает только одну блокировку. Это означает, что если бы wait () был синхронизирован в приведенном выше коде, была бы снята только одна блокировка. Подразумевается, что текущий поток будет ждать с блокировкой очереди.