wait 和sleep 的区别_wait sleep区别-优快云博客

本文链接：https://blog.youkuaiyun.com/leichenlei/article/details/95947838

本文探讨了Java中wait和sleep的区别，重点在于wait在synchronized块中使用并释放锁，而sleep则不会释放锁。通过实验展示了wait使得线程在等待期间释放锁，而线程在sleep期间仍持有锁，直到休眠结束。

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

1，区别

wait 和sleep 的区别如下：

1， wait 是 Object的方法，sleep是Thread的方法

2，wait 必须在synchronized里使用，sleep不用。

3，wait会释放锁，sleep不会。

2，实验

下面我们只研究上线的第3条：wait会释放锁，sleep不会。

2.1，wait释放锁

package com.test.lock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    public static final Logger logger = LoggerFactory.getLogger("[test]");

    public static void main(String[] args) throws InterruptedException {
        //定义个对象
        Object obj = new Object();

        //线程A获取obj的固有锁，并且等待
        Thread A = new Thread("线程A"){
            @Override
            public void run() {
                synchronized (obj){
                    try {
                        logger.info("A等待之前");
                        obj.wait(10000l);
                        logger.info("A等待之后");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        //线程b获取obj的固有锁，并唤醒线程a
        Thread B = new Thread("线程B"){
            @Override
            public void run() {
                synchronized (obj){
                    logger.info("B唤醒a之前");
                    obj.notify();
                    logger.info("B唤醒a之前");
                }
            }
        };

        A.start();
        Thread.sleep(1000l);
        B.start();
    }
}

输出结果：

11:38:30.823 [线程A] INFO [test] - A等待之前
11:38:31.816 [线程B] INFO [test] - B唤醒a之前
11:38:31.816 [线程B] INFO [test] - B唤醒a之前
11:38:31.817 [线程A] INFO [test] - A等待之后

说明：

线程A用synchronized获取obj的固有锁，然后进入了wait状态。

线程B尝试用synchronized获取obj的固有锁，成功获取，并且尝试唤醒等待在obj上的线程A。

A被唤醒，从新获取锁。

结论：A没有等待10s，就可以获取锁，wait状态是释放锁的。

2.2，sleep不会释放锁

package com.test.lock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    public static final Logger logger = LoggerFactory.getLogger("[test]");

    public static void main(String[] args) throws InterruptedException {
        //定义个对象
        Object obj = new Object();

        //线程A获取obj的固有锁，并且等待
        Thread A = new Thread("线程A"){
            @Override
            public void run() {
                synchronized (obj){
                    try {
                        logger.info("A等待之前");
                       Thread.sleep(10000l);
                        logger.info("A等待之后");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        //线程b获取obj的固有锁，并唤醒线程a
        Thread B = new Thread("线程B"){
            @Override
            public void run() {
                synchronized (obj){
                    logger.info("B获取了obj的固有锁");
                }
            }
        };

        A.start();
        Thread.sleep(1000l);
        B.start();
    }
}

11:51:49.286 [线程A] INFO [test] - A等待之前
11:51:59.291 [线程A] INFO [test] - A等待之后
11:51:59.291 [线程B] INFO [test] - B获取了obj的固有锁

说明

线程A用synchronized获取obj的固有锁，然后进入了sleep状态10秒钟。

线程B尝试用synchronized获取obj的固有锁，等了A 10秒钟之后菜获取到obj的固有锁。

所以，sleep并不会释放锁。