应该从同步块调用: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是等待，直到其他线程调用你，而sleep是在指定的一段时间内“不执行下一个语句”。

此外，sleep是Thread类中的静态方法，它在线程上操作，而wait()是Object类中的静态方法，在对象上调用。

还有一点，当你在某个对象上调用wait时，线程同步该对象，然后等待。：）

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 () 当它进入等待阶段时，它将释放键，并根据参数等待一些秒。

例如:

你的右手拿着咖啡，你可以拿另一个同手的任何一个人，什么时候你会放下然后只拿另一个同类型的物体在这里。也。这是sleep() 你睡觉的时候你什么工作都没做，你只是在睡觉。这里也一样。

wait()。当你被放下，在等待的时候再拿一个，那就是等待

你在你的系统中播放电影或任何东西，就像播放器一样，你一次不能播放多个，对吧，就是在这里，当你关闭并选择另一个任何人的电影或歌曲时，这意味着等待

等待和睡觉是两回事:

在sleep()中，线程在指定的时间内停止工作。 在wait()中，线程停止工作，直到被等待的对象被通知，通常由其他线程通知。

一个等待线程可以被另一个调用正在被等待的监视器上的notify线程“唤醒”，而一个睡眠线程则不能。另外，一个wait(和notify)必须发生在monitor对象上同步的块中，而sleep则不会:

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

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

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

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

如果有多个线程在监视器上等待，您也可以调用notifyAll—这将唤醒所有线程。但是，只有一个线程能够获取监视器(记住，等待是在同步块中)并继续执行—其他线程将被阻塞，直到它们获得监视器的锁。

另一点是你在对象本身调用wait(即你在对象的监视器上调用wait)，而你在线程上调用sleep。

还有一点是，你可以从wait中得到虚假的唤醒(例如，正在等待的线程没有明显的原因就恢复了)。你应该总是等待在某些条件下旋转，如下所示:

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

关于睡眠不释放锁，等待释放锁的例子

这里有两个类:

Main:包含Main方法和两个线程。 单例:这是一个单例类，有两个静态方法getInstance()和getInstance(boolean isWait)。 公共类Main { private static singletonA = null; private static Singleton singletonB = null; public static void main(String[] args)抛出InterruptedException { 线程threadA =新线程(){ @Override 公共无效运行(){ singletonA = Singleton.getInstance(true); ｝ }; 线程threadB = new Thread() { @Override 公共无效运行(){ singletonB = Singleton.getInstance(); while (singletonA == null) { system . out。println("SingletonA still null"); ｝ if (singletonA == singletonB) { system . out。println("两个单例是相同的"); }其他{ system . out。println("两个单例不相同"); ｝ ｝ }; threadA.start (); threadB.start (); ｝ ｝

and

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

这里由线程a和线程b创建的单例实例是相同的。这意味着线程b在外面等待，直到线程a释放它的锁。

现在通过注释Thread.sleep(500)来更改Singleton.java;Singleton.class.wait(500);． 这里因为Singleton.class.wait(500);方法threadA将释放所有获取锁并进入“Non Runnable”状态，threadB将获得change进入synchronized块。

现在再运行一次:

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

这里由线程a和线程b创建的单例实例是不一样的，因为线程b得到了进入同步块的变化，500毫秒后，线程a从它的最后一个位置开始，并创建了一个新的单例对象。