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

这里有两个类:

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

这些方法用于不同的事情。

Thread.sleep(5000);   // Wait until the time has passed.

Object.wait();        // Wait until some other thread tells me to wake up.

Thread.sleep(n)可以被中断，但是Object.wait()必须被通知。 可以指定等待的最大时间:Object.wait(5000)，这样就可以使用wait，呃，睡眠，但这样你就不得不使用锁了。

这两种方法都不会在休眠/等待时使用cpu。

这些方法是使用本地代码实现的，使用类似的结构，但方式不同。

自己寻找:本机方法的源代码是否可用?文件/src/share/vm/prims/jvm.cpp是起点…

从oracle文档页面的wait()方法的对象:

public final void wait()

导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法。换句话说，这个方法的行为就像简单地执行调用wait(0)一样。 当前线程必须拥有该对象的监视器。线程释放该监视器的所有权并等待，直到另一个线程通知等待该对象监视器的线程被唤醒 可能会出现中断和虚假唤醒 此方法只能由该对象的监视器的所有者的线程调用

这个方法抛出

IllegalMonitorStateException -如果当前线程不是对象的监视器的所有者。 InterruptedException——如果任何线程在当前线程等待通知之前或期间中断了当前线程。抛出此异常时，当前线程的中断状态将被清除。

从oracle文档页关于Thread类的sleep()方法:

public static void sleep(long millis)

使当前正在执行的线程休眠(暂时停止执行)指定的毫秒数，这取决于系统计时器和调度器的精度和准确性。 线程不会失去任何监视器的所有权。

这个方法抛出:

IllegalArgumentException -如果millis的值为负 InterruptedException -如果任何线程中断了当前线程。抛出此异常时，当前线程的中断状态将被清除。

其他关键区别:

Wait()是一个非静态方法(实例方法)，不同于静态方法sleep()(类方法)。

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/interrupt，首先需要保留对休眠线程的引用，然后手动逐个中断它们。

一个来自现实生活的例子很好地解释了这一点，一个经典的餐厅和员工之间用来沟通的方法:服务员把顾客的要求放在一个中心的地方(一块软木板，一张桌子等)，摇铃，然后厨房的工人来接受这些要求。一旦有菜准备好了，厨房工作人员就会再次按铃，让服务员知道并把菜送到顾客面前。

一个尚未提及的关键区别是:

sleep()不会释放它在线程上持有的锁， 同步(锁){ thread . sleep (1000);// LOCK被持有 ｝ Wait()释放它在对象上持有的锁。 同步(锁){ LOCK.wait ();// LOCK不被持有 ｝