чем отличаются методы wait 1000 и sleep 1000

10.04.202210.04.2022 admin 0 Comments

Разница между ожиданием и сном в Java

Быстрый и практический пример разницы между методами sleep() и wait() в Java.

1. Обзор

В этой короткой статье мы рассмотрим стандартные методы sleep() и wait() в ядре Java и поймем различия и сходства между ними.

2. Общие различия между Ожиданием и Сном

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

С другой стороны, Thread.sleep () – это статический метод, который может быть вызван из любого контекста. |/Thread.sleep() приостанавливает текущий поток и не снимает никаких блокировок.

Вот очень упрощенный первоначальный взгляд на эти два основных API в действии:

Выполнение этого примера приведет к следующему результату:

Поток ‘main’ пробуждается после сна в течение 1 секунды Объект ‘ [email protected] ‘ пробуждается после ожидания в течение 1 секунды

3. Просыпаясь, Ждите и спите

Для wait () процесс пробуждения немного сложнее. Мы можем разбудить поток, вызвав методы notify() или notifyAll() на ожидаемом мониторе.

Например, вот как вы можете подождать :

И затем, вот как другой поток может затем разбудить ожидающий поток – вызвав notify() на мониторе :

Выполнение этого примера приведет к следующему результату:

Ожидание завершения потока… Поток завершен. Сумма из этого потока: 704982704

4. Заключение

Это краткое руководство по семантике wait и sleep в Java.

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

Источник

Русские Блоги

Многопоточность Java (три): разница между wait (), sleep (), join () и yield ()

Предисловие

Затем узнайте две концепции:
1. Блокировка пула

Все потоки, которые должны конкурировать за блокировки синхронизации, будут помещены в пул блокировок. Если блокировка текущего объекта была получена одним из потоков, другие потоки должны ждать в этом пуле блокировок. Когда предыдущий поток освобождает синхронизацию lock, пул блокировок. Все потоки будут конкурировать за блокировку синхронизации, и когда поток получит ее, он войдет в очередь готовности и будет ждать выделения ресурсов ЦП.

2. Ожидание бассейна

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

разница

1. метод сна ()

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

2.yield () метод

Метод yield () похож на метод sleep (), и он не снимает «флаг блокировки». Разница в том, что он не имеет параметров. Функция yield () заключается в уступках. Он позволяет текущему потоку чтобы войти в «состояние готовности» из «состояния выполнения», чтобы позволить другим ожидающим потокам получить право на выполнение, но нет гарантии, что после того, как текущий поток вызовет yield (), другие потоки обязательно получат право на выполнение, или может случиться так, что текущий поток вернется в «рабочее состояние», чтобы продолжить работу.

3. метод join ()

Результат выглядит следующим образом

4.wait () метод

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

Результат выглядит следующим образом

Интеллектуальная рекомендация

Tree Дерево отрезков линии】 COGS 2632

Ссылочный блогАвтор:dreaming__ldxИсточник: CSDN Портал последовательности операций 【Название описания】 Последовательность длины n, вес порядкового номера в начале равен 0, есть m операций Поддерживают.

PAT-A-1046 кратчайшее расстояние [префикс и]

The task is really simple: given N exits on a highway which forms a simple cycle, you are supposed to tell the shortest distance between any pair of exits. Input Specification: Each input fi.

Как нарисовать несколько линий ROC на одном графике?

Класс коллекции JAVA

Резюме JAVA-коллекции Один, коллекция 1. Характеристики коллекций: коллекции используются только для хранения объектов, длина коллекции является переменной, и в коллекции могут храниться объекты разны.

MySQL репликация главный-подчиненный + переключатель главный-подчиненный

MySQL репликация главный-подчиненный + переключатель главный-подчиненный 05 января 2018 10:46:35Протрите протирать прыжок Количество просмотров: 5183Более Персональная категория:база данныхЭксплуатаци.

Источник

Разница между wait () и sleep()

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

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

30 ответов

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

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

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

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

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

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

yield() говорит » я закончил с моим timeslice, но у меня все еще есть работа, чтобы делать.» ОС может сразу же дать потоку другой timeslice, или дать какой-то другой поток или обработать CPU податливый поток просто сдаться.

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

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

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

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

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

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

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

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

ждать()

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

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

sleep ()

фрагмент кода для вызова метода ожидания и сна

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

Пример1: используя ждать() и сон():

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

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

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

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

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

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

сходства, которые помогают понять

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

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

это было просто ясное и основное объяснение, если вы хотите больше, чем это, то продолжить чтение.

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

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

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

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

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

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

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

ждать и спать это две разные вещи:

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

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

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

простыми словами, Подождите, пока какой-то другой поток не вызовет вас, тогда как sleep-это «dont execute next statement» в течение определенного периода времени.

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

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

метод wait ().

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

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

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

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

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

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

метод sleep ()

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

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

3) Метод sleep() всегда вызывается нити.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

следует вызывать из синхронизированного блока: wait() метод всегда вызывается из синхронизированного блока, т. е. wait() метод должен заблокировать монитор объекта перед объектом, на котором он вызывается. Но!—2—> метод может быть вызван из вне synchronized блока, т. е. sleep() методу не нужен никакой монитор объекта.

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

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

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

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

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

со страницы документации oracle на ждать() метод Object :

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

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

другой ключ разница:

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

Источник

Русские Блоги

Разница между sleep () и wait () в потоке Java

Разница 1: использование ограничений

Использовать Метод сна может заставить текущий поток спать В конце времени текущий поток продолжает выполняться и может использоваться где угодно, но ему нужно перехватить исключение InterruptedException.

При использовании Метод ожидания должен быть помещен в синхронизированный блок Также необходимо перехватить исключение InterruptedException, и Необходимо приобрести замок объекта 。

а также wait также нужны дополнительные методы notify / notifyAll для пробуждения, их также необходимо поместить в синхронизированный блок и получить блокировку объекта 。

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

Разница 2: Используйте сценарии

Разница 3: категория

Разница 4: снять блокировку

wait может снять блокировку, удерживаемую текущим потоком объекта блокировки, в то время как sleep не делает.

Разница 5: переключение потоков

Спящий режим даст время выполнения ЦП и принудительное переключение контекста, но ждать не обязательно, но все же может быть шанс побороться за блокировку, чтобы продолжить после ожидания 。