【Java进阶】Sleep和Wait方法的区别（多线程）

诗竹白芍

已于 2022-03-17 10:13:29 修改

阅读量281

点赞数

分类专栏： Java 文章标签： java 开发语言后端

于 2022-03-02 13:05:43 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_43918614/article/details/123226664

版权

Java 专栏收录该内容

14 篇文章

订阅专栏

本文详细探讨了Java中wait和sleep两个方法的相同点和不同点，包括它们的语法使用、所属类、唤醒方式、锁的释放以及线程进入的状态。wait方法需要配合synchronized使用，会释放锁并进入WAITING状态，而sleep不会释放锁，线程进入TIMED_WAITING状态。通过实例代码展示了这两种方法在多线程环境中的行为差异。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

相同点：

两者都可以让线程进入休眠的状态，并且两者都可以响应interrupt中断，也就是说线程在休眠的过程中如果收到中断的信号，都可以进行响应并中断，并且都可以抛出InterruptException异常

不同点：

1.两者的语法使用不同

wait方法必须配合synchronized使用，为了验证，我实现了以下代码

    public static void errorTest() throws InterruptedException {
        Object lock = new Object();
        new Thread(()->{
            try {
                System.out.println("wait之前");
                //调用wait方法
                lock.wait();
                System.out.println("wait之后");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        Thread.sleep(100);
        System.out.println("执行notify");
        lock.notify();
    }



-----------------------------------------------------------------------
打印：


wait之前
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Object.java:502)
	at Demo.Demo2.lambda$errorTest$0(Demo2.java:10)
	at java.lang.Thread.run(Thread.java:750)
执行notify
Exception in thread "main" java.lang.IllegalMonitorStateException
	at java.lang.Object.notify(Native Method)
	at Demo.Demo2.errorTest(Demo2.java:19)
	at Demo.Demo2.main(Demo2.java:23)

我们可以看出此时抛出了IllegalMonitorStateException异常，所以我们此时得配合synchronized使用，修改代码如下，我们分别在wait和notify方法上进行上锁

    public static void errorTest() throws InterruptedException {
        Object lock = new Object();
        new Thread(()->{
            try {
                synchronized (lock){
                    System.out.println("wait之前");
                    //调用wait方法
                    lock.wait();
                    System.out.println("wait之后");
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        Thread.sleep(100);
        System.out.println("执行notify");
        synchronized (lock){
            lock.notify();
        }

    }


----------------------------------------------------------------------------
打印：

wait之前
执行notify
wait之后

而我们的sleep可以单独使用无需配合我们synchronize来使用。

2.所属类不同

wait方法属于我们的Object类的方法

而sleep属于Thread类的方法

3.唤醒方式不同

sleep方法必须要传递一个超时时间的参数，且过了超时时间之后线程会自动的唤醒。

而wait方法可以不传递任何参数，不传递任何参数的时候表示永久休眠，直到另外一个线程调用notify和notifyAll之后。

也就是说sleep方法具有主动唤醒的功能，可以类比为，在你睡觉时候，总是会醒的，但是醒的时候得需要设置闹钟（也就是我们所说的超时时间），如果一直不醒那么你就挂了，而你在排队等待时候，你是完全不知道时间的，只有叫到你的时候（也就是线程调用notify和notifyAll之后）才能进行下一步的动作。

4.释放锁不同

wait方法会主动释放锁

而sleep方法则不会主动释放

还是刚才例子，当你熟睡的时候，我们设想你是抱着锁睡觉，如果没人把你唤醒，那么你将会一直抱着锁睡觉，而当你在等待时候，当别人需要锁的时候，此时当你不用的时候便可以让出。

接下来我们sleep使线程休眠2s，然后在另外一个线程尝试获取公共锁，如果能获取到锁，则说明sleep在休眠的时候会释放锁，反之，则不会

我用代码来演示一下：

    public static void errorTest() throws InterruptedException {
        Object lock = new Object();
        new Thread(()->{
            try {
                synchronized (lock){
                    System.out.println("新线程获取到锁："+ LocalDateTime.now());
                    //休眠2s
                    Thread.sleep(2000);
                    System.out.println("新线程获释放锁："+LocalDateTime.now());
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        Thread.sleep(200);
        System.out.println("主线程尝试获取锁："+LocalDateTime.now());
        synchronized (lock){
            System.out.println("主线程获取到锁："+LocalDateTime.now());
        }

    }

----------------------------------------------------------------------
打印：

新线程获取到锁：2022-03-02T12:37:39.120
主线程尝试获取锁：2022-03-02T12:37:39.297
新线程获释放锁：2022-03-02T12:37:41.121
主线程获取到锁：2022-03-02T12:37:41.121

在调用了sleep之后，我们可以看出在主线程尝试获得锁却没有成功，只要sleep执行完之后才释放了锁，主线程才正常的得到了锁，这说明了sleep在休眠的时候不会释放锁。

接下来使用同样的方式将sleep换成wait之后，如图：

    public static void errorTest() throws InterruptedException {
        Object lock = new Object();
        new Thread(()->{
            try {
                synchronized (lock){
                    System.out.println("新线程获取到锁："+ LocalDateTime.now());
                    //休眠2s
                    lock.wait(2000);
                    System.out.println("新线程获释放锁："+LocalDateTime.now());
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        Thread.sleep(200);
        System.out.println("主线程尝试获取锁："+LocalDateTime.now());
        synchronized (lock){
            System.out.println("主线程获取到锁："+LocalDateTime.now());
        }

    }

-------------------------------------------------------------------------------
打印：

新线程获取到锁：2022-03-02T12:42:46.398
主线程尝试获取锁：2022-03-02T12:42:46.577
主线程获取到锁：2022-03-02T12:42:46.577
新线程获释放锁：2022-03-02T12:42:48.399

从上述的结果可以看出，当调用了wait之后，主线程尝试获得锁的时候立马就成功了，这也就说明了wait方法在休眠的时候是释放锁的。

5.线程进入的状态不同

调用sleep会进入TIMED_WAITING有时限等待状态，而调用无参数的wait方法的时候，线程会进入WAITING无线等待状态。

    public static void errorTest() throws InterruptedException {
        Object lock = new Object();
        Thread t1 = new Thread(()->{
            try {
                synchronized (lock){
                    lock.wait();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();

        Thread t2 = new Thread(()->{
            try {
                    Thread.sleep(2000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t2.start();

        System.out.println("wait后进入状态"+t1.getState());
        System.out.println("sleep后进入状态"+t2.getState());

    }

-----------------------------------------------------------------------------------
打印：

wait后进入状态WAITING
sleep后进入状态TIMED_WAITING