java sleep wait 区别

最新推荐文章于 2024-11-01 14:48:20 发布

秋叶清风

最新推荐文章于 2024-11-01 14:48:20 发布

阅读量96

点赞数

分类专栏： java 文章标签： java

原文链接：https://baijiahao.baidu.com/s?id=1647423693517849309&wfr=spider&for=pc

版权

java 专栏收录该内容

55 篇文章 0 订阅

订阅专栏

本文详细对比了Java中线程方法sleep和Object方法wait的四个主要区别：1) sleep不会释放锁，wait会释放锁；2) sleep不依赖同步方法，wait需要在同步块或方法中使用；3) sleep时间到会继续执行，wait需要被唤醒；4) sleep在没有锁的情况下不会抛出异常，wait在没有锁的情况下抛出异常。通过实例代码进行验证和解释。

摘要由CSDN通过智能技术生成

参考愚公要移山1的博客，在此感谢愚公要移山1 java多线程中sleep和wait的4个区别

java sleep wait 区别

sleep是线程方法，wait是Object方法
sleep 不会释放锁， wait会释放锁
sleep不依赖同步方法，wait需要
sleep不需要被唤醒，wait（不给 long timeout 这个参数，则需要唤醒）需要

sleep是线程方法，wait是Object方法
查看java api可以看出
sleep 会释放锁， wait不会释放锁
新建 Test01


/**
 * 测试 sleep 会释放锁， wait不会释放锁
 * 测试sleep
 */
public class Test01 {
    private static String lock = "lock";

    public static void main(String[] args) {
        Test01 test01 = new Test01();
        test01.test01();
        test01.test02();
    }

    /**
     * 线程01
     */
    public void test01(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock){
                    try {
                        String name = Thread.currentThread().getName();
                        System.out.println("该线程 " + name + " 开始执行");
                        Thread.sleep(1000);
                        System.out.println("该线程 " + name + " 结束执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "线程01");
        thread.start();
    }

    /**
     * 线程02
     */
    public void test02(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock){
                    try {
                        String name = Thread.currentThread().getName();
                        System.out.println("该线程 " + name + " 开始执行");
                        Thread.sleep(1000);
                        System.out.println("该线程 " + name + " 结束执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "线程02");
        thread.start();
    }


}

在这里插入图片描述
可以看出，sleep不会释放锁，只有执行结束之后，第二个线程才能获取锁

新建 Test02


/**
 * 测试 sleep 会释放锁， wait不会释放锁
 * 测试wait
 */
public class Test02 {
    private static String lock = "lock";

    public static void main(String[] args) {
        Test02 test02 = new Test02();
        test02.test01();
        test02.test02();
    }

    /**
     * 线程01
     */
    public void test01(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock){
                    try {
                        String name = Thread.currentThread().getName();
                        System.out.println("该线程 " + name + " 开始执行");
                        lock.wait(1000);
                        System.out.println("该线程 " + name + " 结束执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "线程01");
        thread.start();
    }

    /**
     * 线程02
     */
    public void test02(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock){
                    try {
                        String name = Thread.currentThread().getName();
                        System.out.println("该线程 " + name + " 开始执行");
                        lock.wait(1000);
                        System.out.println("该线程 " + name + " 结束执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "线程02");
        thread.start();
    }


}

在这里插入图片描述
当线程01 wait,线程02获取了锁
因此wait会释放锁

sleep不依赖同步方法，wait需要
新建 Test03


/**
 * 测试 sleep不依赖同步方法，wait需要
 * 测试 是否需要 synchronized
 */
public class Test03 {
    private static String lock = "lock";

    public static void main(String[] args) {
        Test03 test03 = new Test03();
        test03.test01();
        test03.test02();
    }

    /**
     * 线程01
     */
    public void test01(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    String name = Thread.currentThread().getName();
                    System.out.println("该线程 " + name + " 开始执行");
                    Thread.sleep(1000);
                    System.out.println("该线程 " + name + " 结束执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "线程01");
        thread.start();
    }

    /**
     * 线程02
     */
    public void test02(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    String name = Thread.currentThread().getName();
                    System.out.println("该线程 " + name + " 开始执行");
                    lock.wait(1000);
                    System.out.println("该线程 " + name + " 结束执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程02");
        thread.start();
    }


}

在这里插入图片描述
这个异常会在三种情况下抛出：
1>当前线程不含有当前对象的锁资源的时候，调用obj.wait()方法;
2>当前线程不含有当前对象的锁资源的时候，调用obj.notify()方法。
3>当前线程不含有当前对象的锁资源的时候，调用obj.notifyAll()方法。

sleep不需要被唤醒，wait（不给 long timeout 这个参数，则需要唤醒）需要
新建 Test04


/**
 * 测试 sleep不依赖同步方法，wait需要
 * 测试 是否需要 synchronized
 */
public class Test04 {
    private static String lock = "lock";

    public static void main(String[] args) {
        Test04 test04 = new Test04();
        test04.test01();
        test04.test02();
    }

    /**
     * 线程01
     */
    public void test01(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    String name = Thread.currentThread().getName();
                    System.out.println("该线程 " + name + " 开始执行");
                    Thread.sleep(1000);
                    System.out.println("该线程 " + name + " 结束执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "线程01");
        thread.start();
    }

    /**
     * 线程02
     */
    public void test02(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock){
                    try {
                        String name = Thread.currentThread().getName();
                        System.out.println("该线程 " + name + " 开始执行");
                        lock.wait();
                        System.out.println("该线程 " + name + " 结束执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "线程02");
        thread.start();
    }


}