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()。当你被放下，在等待的时候再拿一个，那就是等待

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

在这里，我列出了wait()和sleep()方法之间的一些重要区别。 PS:也可以点击链接查看库代码(内部工作，只是为了更好地理解而玩一下)。

wait ()

Wait()方法释放锁。 wait()是Object类的方法。 wait()是非静态方法——public final void wait()会抛出InterruptedException{//…} wait()应该由notify()或notifyAll()方法通知。 Wait()方法需要从循环中调用，以处理假警报。 wait()方法必须从同步上下文(即同步方法或块)调用，否则将抛出IllegalMonitorStateException

睡眠()

Sleep()方法不释放锁。 sleep()是java.lang.Thread类的方法。 sleep()是静态方法——public static void sleep(long millis, int nanos)会抛出InterruptedException{//…｝ 在指定的时间量之后，sleep()将完成。 Sleep()最好不要从循环中调用(即。参见下面的代码)。 Sleep()可以从任何地方调用。没有具体的要求。

参考:等待和睡眠的区别

调用等待和睡眠方法的代码片段

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

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

让我们假设你正在听到歌曲。

只要当前歌曲正在运行，下一首歌就不会播放，即由下一首歌调用Sleep()

如果你完成了这首歌，它会停止，直到你选择播放按钮(notify())它才会播放，即由当前歌曲调用的wait()。

在这两种情况下，歌曲都进入等待状态。

wait()和sleep()的区别

最根本的区别是wait()是Object的非静态方法，sleep()是Thread的静态方法。 主要的区别是wait()释放锁，而sleep()在等待时不释放任何锁。 Wait()用于线程间通信，而sleep()通常用于在执行时引入暂停。 wait()应该从synchronise内部调用，否则我们会得到一个IllegalMonitorStateException，而sleep()可以在任何地方调用。 要从wait()再次启动线程，必须无限期地调用notify()或notifyAll()。至于sleep()，线程肯定会在指定的时间间隔后启动。

相似之处

两者都使当前线程进入不可运行状态。 两者都是本机方法。

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

这里有两个类:

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从它的最后一个位置开始，并创建了一个新的单例对象。

wait()是Object类的一个方法。 sleep()是Thread类的一个方法。 Sleep()允许线程进入睡眠状态x毫秒。 当线程进入睡眠状态时，它不会释放锁。 Wait()允许线程释放锁并进入挂起状态。 当notify()或notifAll()方法被激活时，该线程将处于活动状态 为同一个对象调用。