关于java:漫画如何证明sleep不释放锁而wait释放锁

wait 加锁示例

public class WaitDemo {private static Object locker = new Object();

    public static void main(String[] args) throws InterruptedException {WaitDemo waitDemo = new WaitDemo();

        // 启动新线程，避免主线程被休眠
        new Thread(() -> {
            try {waitDemo.doWait();
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }).start();
        Thread.sleep(200); // 此行自身没有意义，是为了确保 wait() 先执行再执行 notify()
        waitDemo.doNotify();}

    /**
     * 执行 wait()
     */
    private void doWait() throws InterruptedException {synchronized (locker) {System.out.println("wait start.");
            locker.wait();
            System.out.println("wait end.");
        }
    }

    /**
     * 执行 notify()
     */
    private void doNotify() {synchronized (locker) {System.out.println("notify start.");
            locker.notify();
            System.out.println("notify end.");
        }
    }
}

以上程序的执行后果为：

wait start.

notify start.

notify end.

wait end.

代码解析

从上述代码能够看出，咱们给 wait() 和 notify() 两个办法上了同一把锁（locker），但在调用完 wait() 办法之后 locker 锁就被开释了，所以程序能力失常执行 notify() 的代码，因为是同一把锁，如果不开释锁的话，是不会执行 notify() 的代码的，这一点也能够从打印的后果中证实（后果输入程序），所以 综合以上状况来说 wait() 办法是开释锁的。

sleep 加锁示例

public class WaitDemo {private static Object locker = new Object();

    public static void main(String[] args) throws InterruptedException {WaitDemo waitDemo = new WaitDemo();
        // 启动新线程，避免主线程被休眠
        new Thread(() -> {synchronized (locker) {
                try {System.out.println("sleep start.");
                    Thread.sleep(1000);
                    System.out.println("sleep end.");
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }
        }).start();

        Thread.sleep(200);
        waitDemo.doNotify();}

    /**
     * 执行 notify()
     */
    private void doNotify() {synchronized (locker) {System.out.println("notify start.");
            locker.notify();
            System.out.println("notify end.");
        }
    }
}

以上程序的执行后果为：

sleep start.

sleep end.

notify start.

notify end.

代码解析

从上述代码能够看出 sleep(1000) 办法（行号：11）执行之后，调用 notify() 办法并没有获取到 locker 锁，从上述执行后果中能够看出，而是执行完 sleep(1000) 办法之后才执行的 notify() 办法，因而能够证实调用 sleep() 办法并不会开释锁。

常识扩大

1.sleep 和 wait 有什么区别？

sleep 和 wait 简直是所有面试中必问的题，但想齐全答复正确仿佛没那么简略。

对于 sleep 和 wait 的区别，通常的答复是这样的：

• wait 必须搭配 synchronize 一起应用，而 sleep 不须要；
• 进入 wait 状态的线程可能被 notify 和 notifyAll 线程唤醒，而 sleep 状态的线程不能被 notify 办法唤醒；
• wait 通常有条件地执行，线程会始终处于 wait 状态，直到某个条件变为真，然而 sleep 仅仅让你的线程进入睡眠状态；
• wait 办法会开释对象锁，但 sleep 办法不会。

但下面的答复显然脱漏了一个重要的区别，在调用 wait 办法之后，线程会变为 WATING 状态，而调用 sleep 办法之后，线程会变为 TIMED_WAITING 状态。

2.wait 能不能在 static 办法中应用？为什么？

不能，因为 wait 办法是实例办法（非 static 办法），因而不能在 static 中应用，源码如下：

public final void wait() throws InterruptedException {wait(0);
}

3.wait/notify 能够不搭配 synchronized 应用吗？为什么？

不行，因为不搭配 synchronized 应用的话程序会报错，如下图所示：

更深层次的起因是因为不加 synchronized 的话会造成 Lost Wake-Up Problem，唤醒失落的问题，详情可见：https://juejin.im/post/5e6a4d8a6fb9a07cd80f36d1

总结

本文咱们通过 synchronized 锁定同一对象，来测试 wait 和 sleep 办法，再通过执行后果的先后顺序证实：wait 办法会开释锁，而 sleep 办法并不会。同时咱们还讲了几个 wait 和 sleep 的常见面试问题，心愿本文能够帮忙到你。

关注公众号「Java 中文社群」获取更多精彩内容。