Thread.sleep()不释放锁 Object.wait()释放锁

sleep()方法
sleep()方法是线程类（Thread）的静态方法，让调用的线程进入指定时间睡眠状态，使得当前线程进入阻塞状态。
当线程获取锁时，sleep()方法不会释放对象锁
wait()方法
wait()方法是Object类里的方法， wait()方法、notify()方法和notiftAll()方法用于协调多线程对共享数据的存取，所以只能在同步方法或者同步块中使用，否则抛出IllegalMonitorStateException。

这里用两段代码演示

sleep不会释放锁

public class SleepTeset {
    public static void main(String[] args) {
        final Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程1获取到锁");
                System.out.println("线程1执行sleep()");
                try {
                    Thread.sleep(3000);
                    System.out.println("线程1苏醒了——释放了锁");

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

        Thread thread2 = new Thread(() -> {
                // 睡眠一段时间，确保线程1先获取到锁并执行wait()
            System.out.println("现在是线程2");
//                Thread.sleep(1000);
            synchronized (lock) {
                System.out.println("线程2获取到锁");
                System.out.println("线程2释放锁");
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

当线程1执行 Thread.sleep() 后，线程2开始执行了，但是进不去synchronized代码块，直到3秒后才继续执行线程1，因为 sleep方法不会释放锁

wait会释放锁

public class WaitTest {
    public static void main(String[] args) {
        final Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程1获取到锁");
                System.out.println("线程1执行sleep()");
                try {
                    lock.wait(3000);
                    System.out.println("线程1回来啦");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
                // 睡眠一段时间，确保线程1先获取到锁并执行wait()
            System.out.println("现在是线程2");
//                Thread.sleep(1000);
            synchronized (lock) {
                System.out.println("线程2获取到锁");
                System.out.println("线程2释放锁");
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

这里虽然 wait(3000) 延迟了3秒，但执行线程2的时候没有延迟，可以自己复制去试试，就是因为线程2在执行 synchronized 代码块时可以直接获取锁