二、了解 Java 多线程 （入门篇）

 

今天，来聊一聊线程的 sleep() 方法和 wait() 方法的区别：

首先，先看源码：

可以看出，sleep() 方法是 Thread 类的方法，底层是直接调用的 C++文件去执行线程的 sleep();

而wait()方法则是 Object类的方法，而我们知道，Java中Object类是所有类的父类，也就意味着，所有的类都有 wait() 方法。wait()方法的底层也是调用的 C++ 文件的方法去执行。

共同点：sleep()方法与 wait()方法都可以让线程暂停一段时间：

public class OrderAppTest {

    public static void main(String[] args) {
        Test test = new Test();
        System.out.println("mainThread beginTime：" + System.currentTimeMillis());
        test.start();
    }
}

class Test extends Thread {

    @Override
    public void run() {
        try {
            sleep(5000);
            System.out.println("Runnable beginTime：" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 sleep()方法停止线程的效果如下：

再来看 wait() 方法的效果：

public class OrderAppTest {
    public static Object object = new Object();

    public static void main(String[] args) {
       synchronized (object){
           System.out.println("mainThread beginTime：" + System.currentTimeMillis());
           try {
               object.wait(5000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("mainThread endTime:" + System.currentTimeMillis());
       }
    }
}

运行效果图如下：

从代码的运行效果上看，sleep() 方法和 wait() 方法都具备使线程暂停一段时间的效果。【可能有些初学者看不懂wait()的使用示例代码，稍后，我会介绍 synchronized 关键字和 wait() 方法的使用方法】

 

不同点：sleep() 方法暂停期间，不会释放锁，而 wait() 方法被执行后，会立即释放锁，关于锁的理解，请看这篇文章：【https://blog.csdn.net/shizhiqian0021/article/details/106062934】

照例，通过一段测试代码来理解一下：

public class OrderAppTest {

    public static void main(String[] args) {
        Test test = new Test();
        Thread a = new Thread(test, "A");
        Thread b = new Thread(test, "B");
        a.start();
        b.start();
    }
}
class Test extends Thread{
    @Override
    synchronized public void run() {
        System.out.println(currentThread().getName() + "线程,BeginTime：" + System.currentTimeMillis());
        try {
            sleep(5000 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(currentThread().getName() + "线程,EndTime：" + System.currentTimeMillis());
    }
}

运行该段代码，打印结果如下：

从运行结果可以看出，在A线程sleep()期间，B线程拿不到锁，无法进入run()方法；由此，得出结论：sleep()方法暂停期间，线程是不释放锁的。

下面我们来看 wait() 方法：

public class OrderAppTest {

    public static void main(String[] args) {
        Test test = new Test(new Object());
        Thread a = new Thread(test, "A");
        Thread b = new Thread(test, "B");
        a.start();
        b.start();
    }
}
class Test extends Thread{
    private Object object;

    public Test(Object object) {
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object){
            System.out.println(currentThread().getName() + "线程,BeginTime：" + System.currentTimeMillis());
            try {
                object.wait(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(currentThread().getName() + "线程,EndTime：" + System.currentTimeMillis());
        }
    }
}

运行该段代码，打印结果如下：

从运行结果可以看出，A线程开始以后，执行到 object.wait(5000)处，A线程停止5秒，同时立即释放锁，这时，等待获取object对象锁的B线程获得锁，开始执行，同样执行到object.wait(5000)处，B线程停止5秒，同时，释放锁；A线程苏醒，获得锁，继续执行wait()之后的代码，执行完成，A线程释放锁；B线程苏醒后，A线程已经执行完成并释放锁，B线程重新获得锁，继续执行wait()之后的代码，执行完成，B线程释放锁，程序运行结束。故，得出结论：wait() 暂停期间，会释放锁，当暂停时间结束后，线程会重新去争夺锁，然后继续运行wait()方法之后的代码。

 

接下来，我们继续看一下wait()方法：wait()方法的JDK源码其实已经讲的很清楚了：

    /**
     * @param      timeout   the maximum time to wait in milliseconds.
     * @throws  IllegalArgumentException      if the value of timeout is
     *               negative.
     * @throws  IllegalMonitorStateException  if the current thread is not
     *               the owner of the object's monitor.
     * @throws  InterruptedException if any thread interrupted the
     *             current thread before or while the current thread
     *             was waiting for a notification.  The <i>interrupted
     *             status</i> of the current thread is cleared when
     *             this exception is thrown.
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#notifyAll()
     */
    public final native void wait(long timeout) throws InterruptedException;

 

我们看，方法注解里抛出的第二个异常说明：翻译一下就是：

如果当前线程不是对象监视器的所有者(这里所说的对象监视器即：锁)。则会抛出 IllegalMonitorStateException 异常。也就是说，调用wait()方法，必须持有对象锁，否则会抛出异常。

而调用sleep()方法则不需要持有对象锁。

    /**     
     * @param  millis
     *         the length of time to sleep in milliseconds
     *
     * @throws  IllegalArgumentException
     *          if the value of {@code millis} is negative
     *
     * @throws  InterruptedException
     *          if any thread has interrupted the current thread. The
     *          <i>interrupted status</i> of the current thread is
     *          cleared when this exception is thrown.
     */
    public static native void sleep(long millis) throws InterruptedException;

注意看wait()方法和sleep()方法的注解，两个方法抛出的异常中，sleep()方法不会抛出 IllegalMonitorStateException异常，也就是说，调用sleep()方法时，是否持有对象锁其实无所谓，都不会报错。

 

最后，总结一下：

wait() 与 sleep() 的相同点：

都可以使线程暂停一段时间。

不同点：

sleep()方法是 Thread 类的方法，wait()方法是 Object 类的方法。

调用sleep()不需要当前线程持有对象锁，而wait()方法则需要当前线程必须持有对象锁，否则抛出 IllegalMonitorStateException 异常。

如果调用sleep() 方法的线程持有锁的话，sleep()方法被调用后，该线程不会释放锁，会等待sleep()暂停时间之后，继续执行其后的代码。而wait()方法则会立即释放锁，然后当wait()暂停时间之后，回去重新争夺锁，然后再继续执行wait()之后的代码。