在研究了wait和sleep之后，我总结了一些不同的关键注意事项，首先看一下使用wait()和sleep()的示例:

例1:使用wait()和sleep():

synchronized(HandObject) {
    while(isHandFree() == false) {
        /* Hand is still busy on happy coding or something else, please wait */
        HandObject.wait();
    }
}

/* Get lock ^^, It is my turn, take a cup beer now */
while (beerIsAvailable() == false) {
    /* Beer is still coming, not available, Hand still hold glass to get beer,
       don't release hand to perform other task */
    Thread.sleep(5000);
}

/* Enjoy my beer now ^^ */
drinkBeers();

/* I have drink enough, now hand can continue with other task: continue coding */
setHandFreeState(true);
synchronized(HandObject) {
    HandObject.notifyAll();
}

让我们明确一些关键的注意事项:

呼吁: wait():调用当前持有handdobject对象的线程 sleep():在线程上调用执行任务获取啤酒(是类方法，因此影响当前运行的线程) 同步: wait():当同步多线程访问同一对象(HandObject)时(当多个线程之间需要通信时(线程执行编码，线程执行获取啤酒)访问同一对象(HandObject) sleep():当等待状态继续执行时(等待啤酒可用) 持有锁: wait():释放锁，让其他对象有机会执行(HandObject是空闲的，你可以做其他工作) sleep():保持锁至少t次(或直到中断)(我的工作仍然没有完成，我继续持有锁，等待一些条件继续) 唤醒条件: wait():直到调用notify()， notifyAll()从对象 Sleep():直到至少超时或调用中断 最后一点是当estani表示:

通常使用sleep()进行时间同步，使用wait()进行时间同步 multi-thread-synchronization。

如果我说错了，请指正。

等待和睡眠的方法非常不同:

睡眠无法“唤醒”， 而wait在等待期间有一种“唤醒”的方式，由另一个线程调用notify或notifyAll。

仔细想想，这些名字在这方面令人困惑;然而，sleep是一个标准名称，而wait就像Win API中的WaitForSingleObject或WaitForMultipleObjects。

来源:http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/

wait()方法。

1)调用wait()方法的线程释放它持有的锁。

2)在其他线程调用同一锁上的notify()或notifyAll()方法后，线程重新获得锁。

3) wait()方法必须在同步块内调用。

4) wait()方法总是在对象上被调用。

5)等待中的线程可以通过调用notify()或notifyAll()方法被其他线程唤醒。

6)要调用wait()方法，线程必须有对象锁。

睡眠()方法

1)调用sleep()方法的线程不释放它持有的锁。

2) sleep()方法可以在同步块内部或外部调用。

3) sleep()方法总是在线程上调用。

4)睡眠线程不能被其他线程唤醒。如果这样做，线程将抛出InterruptedException。

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

等待和睡觉是两回事:

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

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