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

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

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


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

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

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

sleep(n) говорит "я сделал с моим тайм-Лисом, и, пожалуйста, не давай мне ... еще один, по крайней мере, на n миллисекунд." ОС даже не пытается запланируйте спящий поток, пока не пройдет запрошенное время.

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

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

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

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

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

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

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

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

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

они могут быть реализованы таким же образом в базовой ОС или вообще не реализованы (поскольку предыдущие версии Java не имели реальной многопоточности; вероятно, некоторые небольшие VMs тоже этого не делают). Не забывайте, что 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

sleep ()

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

Ref: разница между ожиданием и Спи!--31-->

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

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

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

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

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

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 (): вызов по потоку выполнить задачу получить пиво (метод класса так влияет на текущий текущий поток)
2. синхронизироваться:
   • wait (): при синхронизированном многопоточном доступе к одному объекту (HandObject) (когда требуется связь между более чем одним потоком (кодирование выполнения потока, выполнение потока получить пиво) доступ к одному объекту HandObject)
   • sleep (): при условии ожидания для продолжения выполнения (ожидание пива доступно)
3. удерживайте замок:
   • wait (): отпустите блокировку для другого объекта, чтобы выполнить (HandObject свободен, вы можете выполнить другую работу)
   • sleep (): держите блокировку по крайней мере t раз (или до прерывания) (моя работа все еще не закончена, я продолжаю удерживать блокировку и жду некоторого условия для продолжения)
4. состояние пробуждения:
   • wait (): пока вызов не уведомит(), notifyAll() из объекта
   • sleep (): по крайней мере, до истечения времени или прерывания вызова
5. и последнее:использовать, когда as estani указать:

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

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

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

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

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

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

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

• чтобы снова запустить поток из wait() позвони notify() или notifyAll(). Пока в sleep(), поток запускается после указанного интервала ms/sec.

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

• оба делают текущий поток переходит в Не Выполнимое государство.
• оба native методы.

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

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

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

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

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

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

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

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

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

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

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

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

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

object.wait() отправляет текущий поток в "Не Выполнимое" государство, как sleep(), но с изюминкой. Wait вызывается для объекта, а не поток; мы называем этот объект " объект блокировки.- Раньше! .. --6--> is вызывается, текущий поток должен синхронизироваться на объекте блокировки;wait() затем освобождает эту блокировку и добавляет поток в " список ожидания" связано с замком. Позже, другой поток может синхронизироваться на тот же объект блокировки и вызов lock.notify(). Это пробуждает оригинал., ожидающий поток. В основном, wait()/notify() как sleep()/interrupt(), только активный поток не нуждается в прямой указатель на спящий поток, но только на общий объект блокировки.

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

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

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

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

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

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

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

• sleep не "просыпается",
• , тогда как wait имеет способ "пробуждения" во время периода ожидания, другим потоком, вызывающим notify или notifyAll.

подумайте об этом, имена в этом отношении сбивают с толку; однако sleep - это стандартное Имя и wait Как WaitForSingleObject или WaitForMultipleObjects в API Win.

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

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

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

с этого поста : 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 (), поток должен иметь блокировку объекта.

метод sleep ()

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

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

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

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

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

сон

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

ждать

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

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.

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

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

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

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

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

Wait() и 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.

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

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

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

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

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

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

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

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

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

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

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

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

2. Синглтон : это одноэлементный класс с двумя статическими методами getInstance () и getInstance (boolean 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

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

теперь измените Синглтон.java, комментируя поток.сон(500); метод и раскомментировав Синглтон.класс.ждать(500); . Здесь из-за Синглтона.класс.подождите (500); метод threadA освободит все блокировки получения и перейдет в состояние" не запускаемый", 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

здесь одноэлементные экземпляры, созданные 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:

public final void wait()

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

этот метод выдает

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

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

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

public static void sleep(long millis)

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

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

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

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

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

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

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

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