线程中sleep()和wait()的差别

基本的差别

• sleep是Thread类的方法，wait是Object类中定义的方法
• sleep()方法可以在任何地方使用
• wait()方法只能在synchronized方法或者synchronized块中使用

本质区别

• Thread.sleep()只会让出CPU资源，不会导致锁行为的改变
• Object.wait()不仅让出CPU资源，还会释放已经占有的同步锁

我们来看下面两个例子

package com.mtli.thread;

/**
 * @Description:
 * @Author: Mt.Li
 * @Create: 2020-05-05 07:56
 */
public class WaitSleepDemo {
    public static void main(String[] args) {
        final Object lock = new Object();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程A正在等待获取同步锁");
                try {
                    synchronized (lock) {
                        System.out.println("线程A已经获取到锁");
                        Thread.sleep(20);
                        System.out.println("线程A执行wait方法");
                        lock.wait(1000);
                        System.out.println("线程A执行完毕");
                    }
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程B正在等待获取同步锁");
                try {
                    synchronized (lock) {
                        System.out.println("线程B已经获取到锁");
                        Thread.sleep(10);
                        System.out.println("线程B执行sleep方法");
                        Thread.sleep(1000);
                        System.out.println("线程B执行完毕");
                    }
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

}

// 执行结果：

线程A正在等待获取同步锁
线程A已经获取到锁
线程B正在等待获取同步锁
线程A执行wait方法
线程B已经获取到锁
线程B执行sleep方法
线程B执行完毕
线程A执行完毕

从结果我们可以分析，线程A执行wait()方法之前，线程B只是启动运行并在锁池中进行等待，线程A执行wait()方法之后，线程B需要获取锁才能执行的部分被执行了，说明这个时候，线程B获取到了lock对象锁，也就验证了wait不仅仅释放CPU资源，还会释放同步锁，这时候该线程就会进入当前对象的等待池中，等待时间结束，或者被主动唤醒。

对代码稍加修改：

package com.mtli.thread;

/**
 * @Description:
 * @Author: Mt.Li
 * @Create: 2020-05-05 07:56
 */
public class WaitSleepDemo {
    public static void main(String[] args) {
        final Object lock = new Object();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程A正在等待获取同步锁");
                try {
                    synchronized (lock) {
                        System.out.println("线程A已经获取到锁");
                        Thread.sleep(20);
                        System.out.println("线程A执行sleep方法");
                        Thread.sleep(1000);
                        System.out.println("线程A执行完毕");
                    }
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程B正在等待获取同步锁");
                try {
                    synchronized (lock) {
                        System.out.println("线程B已经获取到锁");
                        Thread.sleep(10);
                        System.out.println("线程B执行sleep方法");
                        Thread.sleep(1000);
                        System.out.println("线程B执行完毕");
                    }
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

}

// 结果：

线程A正在等待获取同步锁
线程A已经获取到锁
线程B正在等待获取同步锁
线程A执行sleep方法
线程A执行完毕
线程B已经获取到锁
线程B执行sleep方法
线程B执行完毕

从结果可以显而易见，sleep方法并不会释放锁，但是会释放CPU资源（出让CPU时间片，毕竟Java线程是抢占式的）

以上均为个人理解，若有错误，请各位看官及时提出（轻喷），如有争议，大家可以一起交流