wait方法会释放同步块里的所有锁么？

示例代码

public class TestMain {
    //对象锁一
    private static Object lock1 = new Object();
    //对象锁二
    private static Object lock2 = new Object();

    public static void main(String[] args) throws Exception {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock1) {
                    System.out.println("线程一拿到了lock1锁");
                    System.out.println("线程一准备获取lock2锁");
                    synchronized (lock2) {
                        System.out.println("线程一拿到了lock2锁");
                        try {
                            System.out.println("线程一释放了lock1锁");
                            lock1.wait();
                            System.out.println("线程一运行结束");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //睡眠一秒，让线程一能够成功运行到wait()方法，释放lock1锁
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("线程二拿到了lock1锁，开始运行");
                    System.out.println("线程二准备获取lock2锁");
                    synchronized (lock2) {
                        System.out.println("线程二拿到了lock2锁，开始运行");
                        System.out.println("线程二运行结束");
                    }
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}

运行结果:

从运行结果可以看出，线程一调用了lock1.wait()后，释放了lock1锁，所以线程二成功拿到lock1锁，开始了运行，不过由于线程一没有释放lock2锁，所以线程二会一直在等待获取lock2锁，从而无法进入lock2锁的同步代码块逻辑中。

那怎么让线程一和线程二都能够顺利执行结束呢？

因为只有两个线程在互相协作，所以使用notify()方法做个优化：

优化代码示例:

public class TestMain {
    //对象锁一
    private static Object lock1 = new Object();
    //对象锁二
    private static Object lock2 = new Object();

    public static void main(String[] args) throws Exception {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock1) {
                    System.out.println("线程一拿到了lock1锁");
                    System.out.println("线程一准备获取lock2锁");
                    synchronized (lock2) {
                        System.out.println("线程一拿到了lock2锁");
                        try {
                            System.out.println("线程一释放了lock1锁");
                            //先让出lock1锁，不设置超时时间
                            lock1.wait();
                            //唤醒lock1等待的线程
                            lock1.notify();
                            System.out.println("线程一运行结束");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //睡眠一秒，让线程一能够成功运行到wait()方法，释放lock1锁
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("线程二拿到了lock1锁，开始运行");
                    System.out.println("线程二准备获取lock2锁");
                    //唤醒lock1等待的线程
                    lock1.notify();
                    try {
                        //先让出lock1锁，不设置超时时间
                        lock1.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock2) {
                        System.out.println("线程二拿到了lock2锁，开始运行");
                        System.out.println("线程二运行结束");
                    }
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}

运行结果:

可以看到，线程一和线程二都能够顺利执行结束了。其实本质上就是让他们互相协作，完成工作。

总结

wait方法只会释放当前对象的锁，不会释放所有锁。