Java语言中notify()会立刻释放锁么?

原文链接：https://www.jianshu.com/p/ffc0c755fd8d

问题：notify()会立刻释放锁么?

答案：不会

---

写在前面的话 ： wait(),notify(),notifyAll()必须在同步（Synchronized）方法/代码块中调用，否则会抛IllegalMonitorStateException异常

（1）为什么wait()必须在同步（Synchronized）方法/代码块中调用？

答：调用wait()就是释放锁，释放锁的前提是必须要先获得锁，先获得锁才能释放锁。

（2）为什么notify(),notifyAll()必须在同步（Synchronized）方法/代码块中调用？

答：notify(),notifyAll()是将锁交给含有wait()方法的线程，让其继续执行下去，如果自身没有锁，
怎么叫把锁交给其他线程呢；（本质是让处于入口队列的线程竞争锁）

------------------------------------------------------------------------
这是因为调用这三个方法之前必须拿要到当前锁对象的监视器monitor对象，也就是说notify/notifyAll
和wait方法依赖于monitor对象，又因为monitor存在于对象头的Mark Word中(存储monitor引用指针)，
而synchronized关键字可以获取monitor ，所以，notify/notifyAll和wait方法必须在
synchronized代码块或者synchronized方法中调用。

Object基类的wait() 和notify() 这两个方法的实现,为多线程协作提供了保证。

wait方法

wait是要释放对象锁，进入等待池。
既然是释放对象锁，那么肯定是先要获得锁。
所以wait必须要写在synchronized代码块中，否则会报异常。

notify方法

也需要写在synchronized代码块中,
调用对象的这两个方法也需要先获得该对象的锁.
notify,notifyAll, 唤醒等待该对象同步锁的线程,并放入该对象的锁池中.
对象的锁池中线程可以去竞争得到对象锁,然后开始执行.
​
如果是通过notify来唤起的线程,
那进入wait的线程会被随机唤醒;
(注意: 实际上, hotspot是顺序唤醒的!! 这是个重点! 有疑惑的百度: notify()是随机唤醒线程么?)

如果是通过nootifyAll唤起的线程,
默认情况是最后进入的会先被唤起来,即LIFO的策略;

比较重要的是:

notify()或者notifyAll()调用时并不会真正释放对象锁, 必须等到synchronized方法或者语法块执行完才真正释放锁.

举个例子:

public void test()
{
    Object object = new Object();
    synchronized (object){
        object.notifyAll();
        while (true){
        }
    }
}

如上, 虽然调用了notifyAll, 但是紧接着进入了一个死循环。

这会导致一直不能出临界区, 一直不能释放对象锁。

所以，即使它把所有在等待池中的线程都唤醒放到了对象的锁池中，

但是锁池中的所有线程都不会运行，因为他们始终拿不到锁。

案例分析

为了说明wait() 和notify()方法的功能,

我们举个例子

public class WaitNotifyCase {
​
public static void main(String[] args) {
  final Object lock = new Object();
​
  new Thread(new Runnable() {
      @Override
      public void run() {
          System.out.println("线程 A 等待 获得 锁");
          synchronized (lock) {
              try {
                  System.out.println("线程 A 获得 锁");
                  TimeUnit.SECONDS.sleep(1);
                  System.out.println("线程 A 开始 执行 wait() ");
                  lock.wait();
                  System.out.println("线程 A 结束 执行 wait()");
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  }).start();
​
  new Thread(new Runnable() {
      @Override
      public void run() {
          System.out.println("线程 B 等待 获得 锁");
          synchronized (lock) {
              System.out.println("线程 B 获得 锁");
              try {
                  TimeUnit.SECONDS.sleep(5);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              lock.notify();
              System.out.println("线程 B 执行 notify()");
          }
      }
  }).start();
}
}

执行结果：

线程 A 等待 获得 锁
线程 A 获得 锁
​
线程 B 等待 获得 锁
​
线程 A 开始 执行 wait()
​
线程 B 获得 锁
线程 B 执行 notify()
​
线程 A 结束 执行 wait()

使用时切记：必须由同一个lock对象调用wait、notify方法

• 当线程A执行wait方法时，该线程会被挂起；

• 当线程B执行notify方法时，会唤醒一个被挂起的线程A；

lock对象、线程A和线程B三者是一种什么关系？

根据上面的案例，可以想象一个场景：

• lock对象维护了一个等待队列list；

• 线程A中执行lock的wait方法，把线程A保存到list中；

• 线程B中执行lock的notify方法，从等待队列中取出线程A继续执行；