Java 并发之 wait、notify 机制三问

1. 调用 notify/notifyAll 之后，会立马释放锁吗？

不会。那么什么时候才释放掉锁从而使得在 WaitSet 中的被唤醒的线程能够有机会重新竞争到锁呢？例如：

synchronized(obj) {
  obj.notify();
  foo();
}

在这段代码中，就是 foo() 方法执行完毕后，会释放掉 obj 对象的锁，换句话说，也就是 synchronized 代码块执行完毕后，从字节码层面也就是执行了 monitorexit 指令之后。

2. notify、notifyAll 有什么区别

• notify()：Calling notify() causes the JVM to select one thread waiting on that condition queue to wake up.
• notifyAll()：Calling notifyAll() wakes up all the threads waiting on that condition queue.

简而言之，唤醒随机一个还是所有的区别，不过需要注意的是唤醒所有并不是所有等待的线程都会同一时刻恢复执行，还是需要竞争从而那个重新获取到锁的线程可以执行，毕竟同一时刻只可能有一个线程可以持有对象的锁。我们可以通过一段代码来理解这其中的差别：

public class NotificationTest {

    private volatile boolean go = false;
  
    private synchronized void shouldGo() throws InterruptedException {
          while (!go) {
              System.out.println(Thread.currentThread() + " is going to wait on this object");
              wait();
              System.out.println(Thread.currentThread() + " is woken up");
          }
          go = false;
      }

      private synchronized void go() {
          while (!go) {
              System.out.println(Thread.currentThread() + " is going to notify all or one thread waiting on this object");
              go = true;
              notify();
          }
      }

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

        Runnable waitTask = () -> {
            try {
                test.shouldGo();
            } catch (InterruptedException e) {
                Logger.getLogger(NotificationTest.class.getName()).log(Level.SEVERE, null, e);
            }
            System.out.println(Thread.currentThread() + " finished execution");
        };

        Runnable notifyTask = () -> {
            test.go();
            System.out.println(Thread.currentThread() + " finished execution");
        };

        Thread t1 = new Thread(waitTask, "WT1");
        Thread t2 = new Thread(waitTask, "WT2");
        Thread t3 = new Thread(waitTask, "WT3");
        Thread t4 = new Thread(notifyTask, "NT1");

        t1.start();
        t2.start();
        t3.start();

        Thread.sleep(200);

        t4.start();
    }
}

我们来一起看下这段代码。

1. 有一个共享的 boolean 类型的变量 go，并且使用 volatile 关键字修饰，保证变量的可见性。
2. 同步方法 shouldGo()：wait 的调用以及将 go 置为 false
3. 同步方法 go()：notify 的调用以及将 go 置为 true。
4. main() 测试方法：3个线程调用 shouldGo()，即3个 wait()，1个线程调用 go()，即 notify()。

运行看下输出结果：

我们再把上述示例代码中 notify() 改成 notifyAll()，再看输出结果：

注意红框部分，调用 notifyAll() 把 WaitSet 中的三个线程都唤醒了，被唤醒的第一个线程执行完了 shouldGo() 方法，并且将 go 变量置为 false，这样导致 notifyAll() 唤醒的后面两个线程因为判断条件不满足再次 wait。而 notify() 只随机唤醒了一个线程。

那么我们怎么区分 notify/notifyAll 的使用场景呢？

我们可以借助于 《Java Concurrent In Practice》:

Single notify can be used instead of notifyAll only when both of the following conditions hold:

• Uniform waiters：Only one condition predicate is associated with the condition queue, and each thread executes the

  same logic upon returning from wait;（只有一个等待条件并且从 wait 放回后执行的逻辑是一样的）

• One-in, one-out：A notification on the condition variable enables at most one thread to proceed.（一次 notify 只唤醒一个线程）。

只有在同时满足上述两种情况下我们可以使用 notify，剩下的场景我们都应使用 notifyAll，从而保证程序的正确性，虽然会导致无效的通知影响性能。

Most classes don’t meet these requirements, so the prevailing wisdom is to use notifyAll in preference to single notify. While this may be inefficient，it is much easier to ensure that you classes behave correctly when using notifyAll instead of notify.

3. wait、notify 方法为啥定义在 Object 类，而不是 Thread 类

• 每个 Java 对象都可以作为锁和条件队列
• 每个对象都可以一个 Monitor 对象与之对应
• 锁标志放在对象头比在 Thread 类中维护一份列表更合理

参考资料：

https://javarevisited.blogspot.com/2012/10/difference-between-notify-and-notifyall-java-example.html#axzz8Nju8slQg

《Java Concurrent In Practice》