Разница между ожиданиями () и сном ()

В чем разница между a wait()и sleep()в потоках?

Насколько я понимаю, wait()поток -ing все еще находится в рабочем режиме и использует циклы ЦП, но sleep()-ing не использует правильные циклы ЦП?

Почему у нас есть и то, wait() и другоеsleep() : как их реализация меняется на более низком уровне?

A waitможет быть "разбужен" другим потоком, вызывающим notifyмонитор, которого ожидают, тогда как a sleepне может. Также wait(и notify) должно происходить в блоке synchronizedобъекта монитора, тогда как sleep:

Object mon = ...;
synchronized (mon) {
    mon.wait();
} 

На этом этапе текущий выполняющий поток ожидает и освобождает монитор . Другой поток может сделать

synchronized (mon) { mon.notify(); }

(на том же monобъекте) и первый поток (при условии, что это единственный поток, ожидающий на мониторе) проснется.

Вы также можете позвонить, notifyAllесли более одного потока ожидает на мониторе - это разбудит их всех . Однако только один из потоков сможет захватить монитор (помните, что он waitнаходится в synchronizedблоке) и продолжить - остальные будут заблокированы, пока не получат блокировку монитора.

Другое дело, что вы звоните waitпо Objectсебе (то есть вы будете ждать на мониторе объекта) , тогда как вы звоните sleepна Thread.

Еще один момент заключается в том, что вы можете получать ложные пробуждения от wait(то есть ожидающая нить возобновляется без видимой причины). Вы всегдаwait должны вращаться при некоторых условиях следующим образом:

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

Одно из ключевых различий пока не упоминается, что во время сна на тему никак не освободить замки она держит, во время ожидания снимает блокировку на объект , который wait()называется на.

synchronized(LOCK) {
    Thread.sleep(1000); // LOCK is held
}


synchronized(LOCK) {
    LOCK.wait(); // LOCK is not held
}

Я нашел этот пост полезным. Это ставит разницу между Thread.sleep(), Thread.yield()и Object.wait()в человеческом плане. Цитировать:

В конечном итоге все сводится к планировщику ОС, который раздает временные интервалы процессам и потокам.

sleep(n)говорит: «Я закончил с моим временным интервалом, и, пожалуйста, не давайте мне еще один, по крайней мере, n миллисекунд». ОС даже не пытается запланировать спящий поток, пока не истечет запрошенное время.

yield()говорит: «Я закончил с моим расписанием, но у меня еще есть над чем работать». ОС может немедленно предоставить потоку другой временной интервал, или дать другому потоку или обработать ЦП, из которого уступил только исходящий поток.

wait()говорит: «Я закончил с моим временным интервалом. Не давай мне еще один таймслайс, пока кто-нибудь не позвонит уведомить (). Как и в случае sleep(), ОС даже не будет пытаться запланировать вашу задачу, пока кто-то не позвонит notify()(или не произойдет один из нескольких других сценариев пробуждения).

Потоки также теряют остаток своего временного интервала, когда выполняют блокировку ввода-вывода и при некоторых других обстоятельствах. Если поток работает через весь временной интервал, ОС принудительно получает контроль примерно так, как если бы yield()он был вызван, чтобы другие процессы могли работать.

Вам это редко требуется yield(), но если у вас есть приложение с большим количеством вычислений и логическими границами задач, вставка yield() может повысить быстродействие системы (за счет времени - переключение контекста, даже только на ОС и обратно, не бесплатно). Измеряйте и проверяйте цели, о которых вы заботитесь, как всегда.

Здесь много ответов, но я не смог найти семантического различия, упомянутого ни в одном.

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

sleep()отправляет поток в спящий режим, как это было раньше, он просто упаковывает контекст и прекращает выполнение в течение предопределенного времени. Поэтому, чтобы разбудить его раньше времени, вам нужно знать ссылку на тему. Это не обычная ситуация в многопоточной среде. Он в основном используется для синхронизации времени (например, пробуждение ровно через 3,5 секунды) и / или жестко закодированной справедливости (просто поспите некоторое время и позвольте другим потокам работать).

wait()напротив, это механизм синхронизации потоков (или сообщений), который позволяет вам уведомлять поток, о котором у вас нет сохраненной ссылки (и нет никакой заботы). Вы можете думать об этом как о шаблоне публикации-подписки ( wait== подписка и notify()== публикация). В основном с помощью notify () вы отправляете сообщение (которое может даже не быть получено вообще, и обычно вас это не волнует).

Подводя итог, вы обычно используете sleep()для синхронизации времени и wait()для многопоточной синхронизации.

Они могут быть реализованы таким же образом в базовой ОС или не реализованы вовсе (так как в предыдущих версиях Java не было реальной многопоточности; вероятно, некоторые небольшие виртуальные машины тоже этого не делают). Не забывайте, что Java работает на виртуальной машине, поэтому ваш код будет преобразован во что-то другое в соответствии с VM / OS / HW, на которой он работает.

Здесь я перечислил несколько важных различий между wait() и sleep()методы.
PS: Также нажмите на ссылки, чтобы увидеть код библиотеки (внутренняя работа, просто поиграйте немного для лучшего понимания).

Подождите()

1. wait() метод снимает блокировку
2. wait()это метод Objectкласса.
3. wait() это нестатический метод - public final void wait() throws InterruptedException { //...}
4. wait() должен быть уведомлен notify() или notifyAll()методы.

5. wait() метод должен вызываться из цикла, чтобы справиться с ложной тревогой.

6. wait() метод должен быть вызван из синхронизированного контекста (т.е. синхронизированный метод или блок), иначе он будет выбрасывать IllegalMonitorStateException

спать()

1. sleep() метод не снимает блокировку
2. sleep() это метод java.lang.Threadкласса.
3. sleep() это статический метод - public static void sleep(long millis, int nanos) throws InterruptedException { //... }
4. по истечении указанного количества времени, sleep() завершено.
5. sleep()лучше не звонить из цикла (т.е. см. код ниже ).
6. sleep()может быть вызван откуда угодно. нет конкретных требований.

Ссылка: разница между ожиданием и сном

Фрагмент кода для вызова метода wait и sleep

synchronized(monitor){
    while(condition == true){ 
        monitor.wait()  //releases monitor lock
    }

    Thread.sleep(100); //puts current thread on Sleep    
}

Есть некоторые заметки о ключевых отличиях, которые я заключаю после работы над wait и sleep, сначала рассмотрим пример, используя wait () и sleep ():

Пример 1 : использование wait () и sleep ():

synchronized(HandObject) {
    while(isHandFree() == false) {
        /* Hand is still busy on happy coding or something else, please wait */
        HandObject.wait();
    }
}

/* Get lock ^^, It is my turn, take a cup beer now */
while (beerIsAvailable() == false) {
    /* Beer is still coming, not available, Hand still hold glass to get beer,
       don't release hand to perform other task */
    Thread.sleep(5000);
}

/* Enjoy my beer now ^^ */
drinkBeers();

/* I have drink enough, now hand can continue with other task: continue coding */
setHandFreeState(true);
synchronized(HandObject) {
    HandObject.notifyAll();
}

Позвольте прояснить некоторые ключевые примечания:

1. Позвоните на :
   • wait (): вызов текущего потока, который содержит объект HandObject
   • sleep (): вызовите выполнение задачи Thread, чтобы получить beer (это метод класса, который влияет на текущий работающий поток)
2. Синхронизировано :
   • wait (): когда синхронизируется многопоточный доступ к одному и тому же объекту (HandObject) (когда требуется связь между несколькими потоками (поток выполняет кодирование, поток выполняет get beer) доступ к одному и тому же объекту HandObject)
   • sleep (): при выполнении условия ожидания для продолжения (ожидание пива доступно)
3. Блокировка удержания :
   • wait (): снять блокировку для другого объекта, который может быть выполнен (HandObject свободен, вы можете выполнять другую работу)
   • sleep (): удерживать блокировку не менее t раз (или до прерывания) (моя работа все еще не завершена, я продолжаю удерживать блокировку и ожидаю продолжения)
4. Состояние пробуждения :
   • wait (): до вызова notify (), notifyAll () из объекта
   • sleep (): пока не истечет хотя бы время или прерывание вызова
5. И последний пункт - использование, когда, как указывают estani :

обычно вы используете sleep () для синхронизации времени и wait () для многопоточной синхронизации.

Пожалуйста, поправьте меня, если я ошибаюсь.

Разница между ожиданиями () и сном ()

• Принципиальное отличие заключается в том, что wait()от Objectи sleep()является статическим методом Thread.

• Основное отличие состоит в том, что wait()освобождает блокировку, но sleep()не снимает блокировку во время ожидания.

• wait()используется для связи между потоками, в то время sleep()как обычно используется для приостановки выполнения.

• wait()должен быть вызван изнутри синхронизировать, иначе мы получим IllegalMonitorStateException, в то время как sleep() может быть вызван в любом месте.

• Чтобы снова начать обсуждение wait(), вы должны позвонить notify()или notifyAll(). Что касается sleep(),потока запускается через указанный промежуток времени.

сходства

• Обе заставляют текущий поток перейти в Not Runnable .
• Оба являются родными методами.

Это очень простой вопрос, потому что оба эти метода имеют совершенно разное использование.

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

Это было просто ясное и простое объяснение, если вы хотите большего, тогда продолжайте читать.

В случае, когда wait()метод переходит в состояние ожидания, он не будет возвращаться автоматически, пока мы не вызовем notify()метод (или notifyAll()если у вас более одного потока в состоянии ожидания и вы хотите разбудить все эти потоки). А для доступа к методам wait()или notify()или вам нужна синхронизация, либо блокировка объекта, либо блокировка класса notifyAll(). И еще одна вещь,wait() метод используется для связи между потоками, потому что если поток переходит в состояние ожидания, вам понадобится другой поток, чтобы разбудить этот поток.

Но в случае sleep()этого есть метод, который используется для удержания процесса в течение нескольких секунд или нужного вам времени. Потому что вам не нужно вызывать какой- notify()либо notifyAll()метод или метод, чтобы вернуть этот поток. Или вам не нужен какой-либо другой поток, чтобы перезвонить этому потоку. Например, если вы хотите, чтобы что-то произошло через несколько секунд, как в игре после поворота пользователя, вы хотите, чтобы пользователь ждал, пока компьютер начнет играть, тогда вы можете упомянуть sleep()метод.

И еще одно важное различие , которое часто спрашивают в интервью: sleep()принадлежит к Threadклассу и wait()относится к Objectклассу.

Это все различия между sleep()и wait().

И у обоих методов есть сходство: они оба являются проверенным оператором, поэтому вам нужно попробовать catch или throws для доступа к этим методам.

Я надеюсь, что это поможет вам.

источник: http://www.jguru.com/faq/view.jsp?EID=47127

Thread.sleep()отправляет текущий поток в состояние «Не работает» на некоторое время. Поток сохраняет мониторы, к которым он обратился - т.е. если поток в настоящее время находится в синхронизированном блоке или методе, никакой другой поток не может войти в этот блок или метод. Если другой поток вызывает, t.interrupt()он разбудит спящий поток.

Обратите внимание, что sleep - это статический метод, который означает, что он всегда влияет на текущий поток (тот, который выполняет метод sleep). Распространенной ошибкой является вызов, t.sleep()где t другой поток; даже тогда будет текущий поток, а не поток.

t.suspend()устарел. С его помощью можно остановить поток, отличный от текущего. Приостановленный поток сохраняет все свои мониторы, и, поскольку это состояние не прерываемо, он подвержен тупику.

object.wait()отправляет текущий поток в состояние «Не работает» , вроде бы sleep(), но с изюминкой. Ожидание вызывается для объекта, а не для потока; мы называем этот объект «объект блокировки». Перед lock.wait()вызовом текущий поток должен синхронизироваться с объектом блокировки; wait() затем снимает эту блокировку и добавляет поток в «список ожидания», связанный с блокировкой. Позже другой поток может синхронизироваться с тем же объектом блокировки и вызывать lock.notify(). Это пробуждает оригинальную ожидающую нить. По сути, wait()/ notify()аналогично sleep()/ interrupt(), только активному потоку не нужен прямой указатель на спящий поток, а только на объект общей блокировки.

Ждать и спать две разные вещи:

• В sleep()потоке перестает работать на указанную продолжительность.
• В wait()потоке перестает работать до тех пор, пока ожидаемый объект не будет уведомлен, как правило, другими потоками.

sleepЭто метод Thread, waitметод Object, так wait/notifyже как и метод синхронизации общих данных в Java (с использованием монитора ), но sleepэто простой метод потоковой приостановки самого себя.

sleep () - это метод, который используется для удержания процесса в течение нескольких секунд или нужного времени, но в случае, когда метод метода wait () переходит в состояние ожидания, и он не возвращается автоматически, пока мы не вызовем notify () или notifyAll ().

Основное отличие состоит в том, что wait () снимает блокировку или монитор, в то время как sleep () не снимает блокировку или монитор во время ожидания. Ожидание используется для связи между потоками, в то время как ожидание используется, чтобы вообще ввести паузу при выполнении.

Thread.sleep () отправляет текущий поток в состояние «Not Runnable» на некоторое время. Поток хранит полученные им мониторы, т. Е. Если поток находится в синхронизированном блоке или методе, никакой другой поток не может войти в этот блок или метод. Если другой поток вызывает t.interrupt (), он разбудит спящий поток. Обратите внимание, что sleep - это статический метод, который означает, что он всегда влияет на текущий поток (тот, который выполняет метод sleep). Распространенной ошибкой является вызов t.sleep (), где t - другой поток; даже тогда будет текущий поток, а не поток.

object.wait () отправляет текущий поток в состояние «не запускается», как sleep (), но с поворотом. Ожидание вызывается для объекта, а не для потока; мы называем этот объект «объект блокировки». Перед вызовом lock.wait () текущий поток должен синхронизироваться с объектом блокировки; Затем wait () снимает эту блокировку и добавляет поток в «список ожидания», связанный с блокировкой. Позже другой поток может синхронизироваться с тем же объектом блокировки и вызывать lock.notify (). Это пробуждает оригинальную ожидающую нить. По сути, wait () / notify () похожа на sleep () / interrupt (), только активному потоку не нужен прямой указатель на спящий поток, а только на объект общей блокировки.

synchronized(LOCK) {   
   Thread.sleep(1000); // LOCK is held
}

synchronized(LOCK) {   
   LOCK.wait(); // LOCK is not held
}

Позвольте классифицировать все вышеперечисленные пункты:

Call on:

• wait (): вызов объекта; текущий поток должен синхронизироваться на объекте блокировки.
• sleep (): вызов по теме; всегда выполняющий поток

Synchronized:

• wait (): когда синхронизированные несколько потоков обращаются к одному и тому же объекту один за другим.
• sleep (): когда синхронизируются несколько потоков, ожидайте перерыва в спящем потоке.

Hold lock:

• wait (): снять блокировку для других объектов, чтобы иметь возможность выполнить.
• sleep (): удерживайте блокировку не менее t раз, если указан тайм-аут или кто-то прерывает.

Wake-up condition:

• wait (): до вызова notify (), notifyAll () из объекта
• sleep (): пока не истечет хотя бы время или вызов interrupt ().

Usage:

• sleep (): для синхронизации времени и;
• wait (): для многопоточной синхронизации.

Ref: diff sleepиwait

Проще говоря, wait is wait До тех пор, пока какой-то другой поток не вызовет вас, тогда как sleep «не выполняет следующую инструкцию» в течение определенного периода времени.

Кроме того, sleep является статическим методом в классе Thread и работает с потоком, тогда как wait () находится в классе Object и вызывается для объекта.

Другой момент, когда вы вызываете wait для какого-либо объекта, вовлеченный поток синхронизирует объект и затем ожидает. :)

waitи sleepметоды очень разные:

• sleep не имеет возможности «проснуться»,
• в то время как waitесть способ «пробуждения» в течение периода ожидания, вызываемый другим потоком notifyили notifyAll.

Если подумать, имена сбивают с толку в этом отношении; однако sleepэто стандартное имя и waitпохоже на WaitForSingleObjectили WaitForMultipleObjectsв Win API.

Из этого поста: http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/

Метод wait ().

1) Поток, который вызывает метод wait (), снимает блокировку, которую он удерживает.

2) Поток восстанавливает блокировку после того, как другие потоки вызывают методы notify () или notifyAll () для той же блокировки.

3) метод wait () должен быть вызван в синхронизированном блоке.

4) метод wait () всегда вызывается для объектов.

5) Ожидающие потоки могут быть разбужены другими потоками путем вызова методов notify () или notifyAll ().

6) Для вызова метода wait () поток должен иметь блокировку объекта.

Метод сна ()

1) Поток, который вызывает метод sleep (), не снимает блокировку, которую он удерживает.

2) метод sleep () может быть вызван внутри или снаружи синхронизированного блока.

3) метод sleep () всегда вызывается в потоках.

4) Спящие нитки не могут быть разбужены другими нитями. Если это сделано, поток выдаст исключение InterruptedException.

5) Чтобы вызвать метод sleep (), поток не должен иметь объектную блокировку.

Здесь wait () будет находиться в состоянии ожидания до тех пор, пока не получит уведомление от другого потока, но когда у функции sleep () будет некоторое время ... после этого он автоматически перейдет в состояние готовности ...

1. wait()это метод Objectкласса.
   sleep()это метод Threadкласса.

2. sleep()позволяет потоку перейти в sleepсостояние в течение x миллисекунд.
   Когда поток переходит в состояние сна it doesn’t release the lock.

3. wait()позволяет потоку снять блокировку и goes to suspended state.
   Этот поток будет активен при вызове метода notify()или notifAll()для того же объекта.

Одна потенциальная большая разница между сном / прерыванием и ожиданием / уведомлением состоит в том, что

• вызов в interrupt()течение sleep()всегда вызывает исключение (например, InterruptedException ), тогда как
• звонить notify()во время wait()нет.

Создание исключения, когда оно не нужно, неэффективно. Если у вас есть потоки, взаимодействующие друг с другом с высокой скоростью, то вы бы генерировали много исключений, если бы вы все время вызывали прерывание, что является полной тратой процессорного времени.

Вы правы - Sleep () приводит к тому, что поток «спит», и процессор отключается и обрабатывает другие потоки (иначе называемые переключением контекста), когда, я полагаю, Wait заставляет процессор обрабатывать текущий поток.

У нас есть и то и другое, потому что, хотя может показаться разумным позволить другим людям использовать процессор, пока вы его не используете, на самом деле существуют издержки на переключение контекста - в зависимости от того, как долго длится спящий режим, он может быть дороже в циклах процессора переключать потоки, чем просто заставить ваш поток ничего не делать в течение нескольких мс.

Также обратите внимание, что сон вызывает переключение контекста.

Кроме того - в общем случае невозможно управлять переключением контекста - во время ожидания ОС может (и будет дольше ожидать) выбрать обработку других потоков.

Методы используются для разных вещей.

Thread.sleep(5000);   // Wait until the time has passed.

Object.wait();        // Wait until some other thread tells me to wake up.

Thread.sleep (n) может быть прерван, но Object.wait () должен быть уведомлен. Можно указать максимальное время ожидания: Object.wait(5000)так что можно было бы использовать waitего, sleepно тогда вам придется беспокоиться о блокировках.

Ни один из методов не использует процессор во время сна / ожидания.

Методы реализованы с использованием нативного кода, с использованием аналогичных конструкций, но не одинаковым образом.

Посмотрите сами: доступен ли исходный код нативных методов? Файл /src/share/vm/prims/jvm.cppявляется отправной точкой ...

Wait () и sleep () Различия?

Thread.sleep () После того, как его работа завершена, только снятие блокировки для всех. пока его никогда не откроет замок никому.

  Sleep() take the key, its never release the key to anyone, when its work completed then only its release then only take the key waiting stage threads.

Object.wait () Когда он перейдет в стадию ожидания, он отпустит ключ и будет ждать несколько секунд в зависимости от параметра.

Например:

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

Подождите(). когда вы подавлены и принимаете другое среднее значение, пока вы ждете, это ожидание

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

waitснимает блокировку и sleepне делает Поток в состоянии ожидания , имеет право на пробуждение , как только notifyили notifyAllназываются. Но в случае, sleepесли поток сохраняет блокировку, он будет иметь право только после окончания времени ожидания.

sleep()Метод заставляет текущий поток переходить из состояния выполнения в состояние блокировки в течение указанного времени. Если текущий поток имеет блокировку какого-либо объекта, он продолжает удерживать ее, что означает, что другие потоки не могут выполнить какой-либо синхронизированный метод в этом объекте класса.

wait() Метод заставляет текущий поток переходить в состояние блока либо на указанное время, либо до момента уведомления, но в этом случае поток снимает блокировку объекта (что означает, что другие потоки могут выполнять любые синхронизированные методы вызывающего объекта.

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

Почему ждать / уведомлять больше подходит? Вот некоторые личные соображения:

1. Это обеспечивает централизацию. Это позволяет координировать связь между группой потоков с одним общим объектом. Это значительно упрощает работу.

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

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

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

Пример сна не снимает блокировку, а ожидание делает

Здесь есть два класса:

1. Main : содержит основной метод и два потока.

2. Singleton : это одноэлементный класс с двумя статическими методами getInstance () и getInstance (логическое isWait).

   public class Main {
   
   private static Singleton singletonA = null;
   private static Singleton singletonB = null;
   
   public static void main(String[] args) throws InterruptedException {
   
   Thread threadA = new Thread() {
       @Override
       public void run() {
   
           singletonA = Singleton.getInstance(true);
   
       }
   };
   
   Thread threadB = new Thread() {
       @Override
       public void run() {
           singletonB = Singleton.getInstance();
   
           while (singletonA == null) {
               System.out.println("SingletonA still null");
           }
   
           if (singletonA == singletonB) {
               System.out.println("Both singleton are same");
           } else {
               System.out.println("Both singleton are not same");
           }
   
       }
   };
   
   threadA.start();
   threadB.start();
   
    }
   }

а также

public class Singleton {

    private static Singleton _instance;

    public static Singleton getInstance() {

    if (_instance == null) {
        synchronized (Singleton.class) {
            if (_instance == null)
                _instance = new Singleton();
        }
    }
    return _instance;

}

public static Singleton getInstance(boolean isWait) {

    if (_instance == null) {
        synchronized (Singleton.class) {
            if (_instance == null) {
                if (isWait) {
                    try {
                        // Singleton.class.wait(500);//Using wait
                        Thread.sleep(500);// Using Sleep
                        System.out.println("_instance :"
                                + String.valueOf(_instance));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                _instance = new Singleton();
            }
        }
    }
    return _instance;

 }
}

Теперь запустите этот пример, вы получите ниже вывод:

_instance :null
Both singleton are same

Здесь экземпляры Singleton, созданные threadA и threadB, одинаковы. Это означает, что threadB ожидает снаружи, пока threadA не снимет свою блокировку.

Теперь измените Singleton.java, комментируя Thread.sleep (500); метод и раскомментирование Singleton.class.wait (500); , Здесь из-за Singleton.class.wait (500); метод threadA снимет все блокировки получения и переместится в состояние «Runnable», а threadB получит изменение для входа в синхронизированный блок.

Теперь запустите снова:

SingletonA still null
SingletonA still null
SingletonA still null
_instance :com.omt.sleepwait.Singleton@10c042ab
SingletonA still null
SingletonA still null
SingletonA still null
Both singleton are not same

Здесь экземпляры Singleton, созданные threadA и threadB, НЕ одинаковы, потому что threadB получил изменение для входа в синхронизированный блок и после 500 миллисекунд threadA начал с своей последней позиции и создал еще один объект Singleton.

Должен вызываться из синхронизированного блока: wait() метод всегда вызывается из синхронизированного блока, т. Е. wait()Метод должен блокировать монитор объекта перед объектом, для которого он вызывается. Но sleep()метод может быть вызван извне синхронизированного блока, т.е.sleep() Метод не нуждается ни в каком объектном мониторе.

IllegalMonitorStateException: если wait()метод вызывается без получения блокировки объекта, он генерируетсяIllegalMonitorStateException во время выполнения, но sleep()метод никогда не генерирует такое исключение.

Принадлежит к какому классу: wait() метод принадлежит java.lang.Objectклассу, но sleep()метод принадлежит java.lang.Threadклассу.

Вызывается для объекта или потока: wait() метод вызывается для объектов, но sleep()метод вызывается для потоков, а не объектов.

Состояниеwait() потока : когда метод вызывается для объекта, поток, который удерживает монитор объекта, переходит из состояния ожидания в состояние ожидания и может вернуться в состояние выполнения только при вызове notify()или notifyAll()метода этого объекта. А позже планировщик потока планирует, что этот поток перейдет из рабочего состояния в рабочее. Когда sleep()вызывается в потоке, он переходит из состояния ожидания в состояние ожидания и может вернуться в состояние выполнения, когда время ожидания истекло.

При вызове из синхронизированного блока: при wait()вызове метода поток покидает объектную блокировку. Но sleep()метод при вызове из синхронизированного блока или потока метода не оставляет объектную блокировку.

Для получения дополнительной ссылки

Со страницы документации оракула о методе wait ()Object :

public final void wait()

1. Заставляет текущий поток ждать, пока другой поток не вызовет notify()метод или notifyAll()метод для этого объекта. Другими словами, этот метод ведет себя точно так же, как если бы он просто выполнял вызов wait(0).
2. Текущий поток должен иметь монитор этого объекта. Поток освобождает владельца этого монитора и ждет, пока другой поток не уведомит потоки, ждущие на мониторе этого объекта, чтобы проснуться
3. возможны прерывания и ложные пробуждения
4. Этот метод должен вызываться только потоком, который является владельцем монитора этого объекта

Этот метод бросает

1. IllegalMonitorStateException - если текущий поток не является владельцем монитора объекта.

2. InterruptedException- если какой-либо поток прервал текущий поток до или в то время, когда текущий поток ожидал уведомления. Прерванное состояние текущего потока очищается при возникновении этого исключения.

Со страницы документации оракула по методу sleep ()Thread класса:

public static void sleep(long millis)

1. Заставляет текущий исполняемый поток в спящий режим (временно прекращать выполнение) на указанное количество миллисекунд, в зависимости от точности и точности системных таймеров и планировщиков.
2. Поток не теряет права собственности ни на какие мониторы.

Этот метод бросает:

1. IllegalArgumentException - если значение миллис является отрицательным

2. InterruptedException- если какой-либо поток прервал текущий поток. Прерванное состояние текущего потока очищается при возникновении этого исключения.

Другое ключевое отличие:

wait()это нестатический метод (метод экземпляра) в отличие от статического метода sleep()(метод класса).

wait()дается внутри синхронизированного метода, тогда sleep()как дается внутри несинхронизированного метода, потому что wait()метод освобождает блокировку объекта, но sleep()или yield()освобождает lock().

• Этот метод wait(1000)заставляет текущий поток спать до одной секунды .
  • Поток может спать менее 1 секунды, если он получает вызов метода notify()илиnotifyAll() .
• При вызове sleep(1000)текущий поток спит ровно 1 секунду .
  • Также спящий поток не удерживает блокировку любого ресурса . Но ожидание потока делает.

Собственно, все это четко описано в документации Java (но я понял это только после прочтения ответов).

http://docs.oracle.com/javase/8/docs/api/index.html :

wait () - текущему потоку должен принадлежать монитор этого объекта. Поток освобождает владельца этого монитора и ожидает, пока другой поток не уведомит потоки, ожидающие на мониторе этого объекта, чтобы он проснулся либо посредством вызова метода notify, либо метода notifyAll. Затем поток ожидает, пока не получит право собственности на монитор, и возобновит выполнение.

sleep () - Заставляет текущий выполняющийся поток спать (временно прекращать выполнение) на указанное количество миллисекунд, в зависимости от точности и точности системных таймеров и планировщиков. Поток не теряет права собственности ни на какие мониторы.