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

这里有两个类:

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

一个等待线程可以被另一个调用正在被等待的监视器上的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(); }
}

简单地说，wait是等待，直到其他线程调用你，而sleep是在指定的一段时间内“不执行下一个语句”。

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

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

Wait()是在同步方法中给出的 而sleep()是在非同步方法中给出的，因为wait()方法会释放对象上的锁，而sleep()或yield()会释放对象上的锁。

实际上，所有这些都在Java文档中有清楚的描述(但我是在阅读答案后才意识到这一点)。

http://docs.oracle.com/javase/8/docs/api/index.html:

wait() -当前线程必须拥有该对象的监视器。线程释放 该监视器的所有权，并等待直到另一个线程通知 在此对象的监视器上等待的线程可以通过 调用notify方法或notifyAll方法。那么线程 等待，直到它可以重新获得监视器的所有权并恢复执行。

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

这里wait()将处于等待状态，直到它被另一个线程通知，而sleep()将有一段时间，之后它将自动转移到就绪状态…