Java wait（）和sleep（）之间的区别

线程中的

wait（）

和

sleep（）

之间有什么区别

我是否理解

wait（）

-ing线程仍处于运行模式并使用CPU周期，但

sleep（）

-ing不使用任何CPU周期

为什么我们有

wait（）

和

sleep（）

：它们的实现在较低的级别上有什么不同？

a可以被另一个线程调用正在等待的监视器“唤醒”，而a不能。此外，监视器对象上的块

已同步
中必须发生
等待
（和
通知
），而
睡眠
不会：

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

此时，当前执行的线程等待并释放监视器。另一个线程也可以

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

（在同一
mon
对象上）和第一个线程（假设它是等待监视器的唯一线程）将被唤醒

如果有多个线程在监视器上等待，您也可以调用，这将唤醒所有线程。但是，只有一个线程能够抓取监视器（请记住，
wait
处于
synchronized
块中）并继续执行–其他线程将被阻止，直到它们能够获得监视器的锁为止

另一点是，您在自身上调用
wait
（即，您在对象的监视器上等待），而在其上调用
sleep

还有一点是，您可以从
wait
获得虚假唤醒（即，正在等待的线程无明显原因地恢复）。在某些条件下旋转时，应始终等待，如下所示：

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

A可以被另一个线程调用正在等待的监视器“唤醒”，而A不能。此外，监视器对象上的块
已同步
中必须发生
等待
（和
通知
），而
睡眠
不会：

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

此时，当前执行的线程等待并释放监视器。另一个线程也可以

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

（在同一
mon
对象上）和第一个线程（假设它是等待监视器的唯一线程）将被唤醒

如果有多个线程在监视器上等待，您也可以调用，这将唤醒所有线程。但是，只有一个线程能够抓取监视器（请记住，
wait
处于
synchronized
块中）并继续执行–其他线程将被阻止，直到它们能够获得监视器的锁为止

另一点是，您在自身上调用
wait
（即，您在对象的监视器上等待），而在其上调用
sleep

还有一点是，您可以从
wait
获得虚假唤醒（即，正在等待的线程无明显原因地恢复）。在某些条件下旋转时，应始终等待，如下所示：

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

简单地说，wait是等待，直到其他线程调用您，而sleep是在指定的时间段内“notexecutenextstatement”

此外，sleep是Thread类中的静态方法，它在Thread上操作，而wait（）在Object类中并在Object上调用

另一点，当您对某个对象调用wait时，涉及的线程将同步该对象，然后等待。：）
 简单地说，wait是等待其他线程调用您，而sleep是在指定的时间段内“不执行下一条语句”

此外，sleep是Thread类中的静态方法，它在Thread上操作，而wait（）在Object类中并在Object上调用

另一点，当您对某个对象调用wait时，涉及的线程将同步该对象，然后等待。：）
 
等待
和
睡眠
方法非常不同：


没有办法“醒来”
然而，在等待期间，通过另一个线程调用或，有一种“唤醒”的方式

想想看，这些名字在这方面令人困惑；但是，
sleep
是一个标准名称，
wait
类似于Win API中的or。
wait
和
sleep
方法非常不同：


没有办法“醒来”
然而，在等待期间，通过另一个线程调用或，有一种“唤醒”的方式

想想看，这些名字在这方面令人困惑；但是，
sleep
是一个标准名称，
wait
类似于Win API中的or。
wait和sleep是两个不同的东西：


在
sleep（）
中，线程在指定的持续时间内停止工作
在
wait（）
中，线程停止工作，直到被等待的对象收到通知为止，通常由其他线程通知
等待和睡眠是两件不同的事情：


在
sleep（）
中，线程在指定的持续时间内停止工作
在
wait（）
中，线程停止工作，直到被等待的对象收到通知为止，通常由其他线程通知
你是对的-Sleep（）会导致该线程“睡眠”，CPU会关闭并处理其他线程（也称为上下文切换），而我相信Wait会让CPU处理当前线程

我们两者都有，因为虽然在你不使用CPU的时候让其他人使用CPU似乎是明智的，但实际上上下文切换是有开销的——取决于睡眠时间的长短，切换线程的CPU周期可能比让线程在几毫秒内什么都不做要昂贵得多

还要注意，睡眠强制进行上下文切换

另外-通常情况下，无法控制上下文切换-在等待期间，操作系统可能（并将等待更长时间）选择处理其他线程。
您是正确的-Sleep（）会导致该线程“睡眠”，CPU将关闭并处理
synchronized(LOCK) {   
   Thread.sleep(1000); // LOCK is held
}

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

  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.

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

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

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

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

public final void wait()

public static void sleep(long millis)