浅谈synchronized、wait、notify和notifyAll

一、概念解读

1. synchronized：同步锁，可修饰类、方法、代码块；
2. wait：使当前线程进入等待状态，直到锁定对象被唤醒（notify、notifyAll），然后当前线程进入就绪状态；可指定最大等待时间，自动唤醒；
3. notify：唤醒当前对象上等待的单个线程；
4. notifyAll：唤醒当前对象上等待的所有县城；

二、sleep?

很多面试题都会涉及到“sleep和wait的区别？”，开始可能都只知道“sleep不会释放锁，而wait会”，再到后面知道“sleep是Thread类的静态方法，而wait是Object的方法”。但是对于刚起步的Java开发者来说，这些真的能理解透吗？普通的编码中几乎不会用到并发的知识，没有coding过难以真正掌握。

并发编程最重要的是线程安全问题。多个线程同时操作一个对象，势必造成不可控的问题。所以锁机制是针对于对象而言的。**wait方法又是针对对象释放锁而言的，所以**wait方法存在Object中。回过头看sleep，目的就是让当前线程休眠。所以sleep存在Thread类中，并且必须指定休眠时长。

三、wait、notify使用场景

synchronized是同步锁，目的是在同步代码块中获取锁，其他线程没持有锁则不能访问，从而保证共享数据线程安全。wait是释放当前对象锁，并且使得当前线程等待，notify（notifyAll）是唤醒对象上等待获取锁的线程，所以wait、notify、notifyAll都必须写在synchronized同步代码区中，否则出现IllegalMonitorStateException异常。

假设一个消费线程，消费操作（减库存）必须是同步的，然后对库存加锁，那么这里就有判断，如果库存不大于0，释放锁，使当前线程等待，知道生产线程（加库存）唤醒，可能很多人这样写：

synchronized(库存){  if(库存为空){    库存.await();  }  // 执行消费，减库存}

咋的一看这样没问题，消费之前判断库存大小，空则释放锁，等待被唤醒，但问题来了，不只是生产线程能够唤醒，可能在其他地方库存被唤醒，但是实际库存并没有变化，就会导致库存大小为负数问题。所以，这里要改为：

synchronized(库存){  while(库存为空){    库存.await();  }  // 执行消费，减库存}

所以wait方法一定是在循环中调用，而不是if语句。

注：有说明notify也是一定要在循环中调用，目前还不知缘由，暂且搁着(*･ω-q) 。

四、实践见真理

上面说了这么多，coding才是王道，采用最简单的生产者消费者模式进一步理解wait和notify。

思路分析：

1. 模拟库存，库存为空时消费线程等待，库存满了时生产线程等待；
2. 执行消费操作后唤醒在库存对象上等待的生产线程，（如果有生产线程等待则可以唤醒继续生产）；
3. 执行生产操作后唤醒在库存对象上等待的消费线程，（如果有消费线程等待则可以唤醒继续消费）；

生产者，将LinkedList比作库存，用一个循环体生产线程：

package com.cjt.concurrent;import java.util.LinkedList;import java.util.Random;import java.util.concurrent.TimeUnit;class Producer implements Runnable {  private final LinkedList<Integer> list;  Producer(LinkedList<Integer> list) {    this.list = list;  }  @Override  public void run() {    while (true) {      synchronized (list) {        while (list.size() >= 3) {          System.out.println("库存已满，等待消费后继续生产");          try {            list.wait();          } catch (InterruptedException e) {            e.printStackTrace();          }        }        System.out.println("开始生产");        list.add(new Random().nextInt());        list.notifyAll();      }      try {        TimeUnit.MILLISECONDS.sleep(10);      } catch (InterruptedException e) {        e.printStackTrace();      }    }  }}

1. synchronized是在while里面，而不是套在while外面？防止一直持有锁没有释放。
2. 为什么将库存定义为final？因为对象锁是基于对象自身的，这里只是引用，如果引用改变了（重新初始化，指向一个新的对象），那么这个锁自然没有价值了。加锁的对象最好定义为final类型。

消费者，假设一个消费线程减少一个库存：

package com.cjt.concurrent;import java.util.LinkedList;final class Consumer implements Runnable {  private final LinkedList<Integer> list;  Consumer(LinkedList<Integer> list){    this.list = list;  }  @Override  public void run() {    synchronized(list){      while (list.isEmpty()) {        System.out.println("库存为空，等待生产");        try {          list.wait();        } catch (InterruptedException e) {          e.printStackTrace();        }      }      System.out.println("消费");      list.remove();      list.notifyAll();    }  }}

主程序，首先开启生产者线程，创建两个消费者线程：

package com.cjt.concurrent;import java.util.LinkedList;import java.util.concurrent.TimeUnit;public class Test {  private static LinkedList<Integer> list = new LinkedList<>();  public static void main(String[] args) throws InterruptedException {    new Thread(new Producer(list)).start();    TimeUnit.SECONDS.sleep(1);    new Thread(new Consumer(list)).start();    TimeUnit.SECONDS.sleep(1);    new Thread(new Consumer(list)).start();  }}

TimeUnit真的很好用，实现线程睡眠可替代Thread.sleep()。

运行主程序观察控制台可发现：

开始生产开始生产开始生产库存已满，等待消费后继续生产消费开始生产库存已满，等待消费后继续生产消费开始生产库存已满，等待消费后继续生产

可以更换主程序线程顺序：

new Thread(new Consumer(list)).start();TimeUnit.SECONDS.sleep(1);new Thread(new Consumer(list)).start();TimeUnit.SECONDS.sleep(1);new Thread(new Producer(list)).start();

再次观测控制台结果：

库存为空，等待生产库存为空，等待生产开始生产开始生产开始生产库存已满，等待消费后继续生产消费消费开始生产开始生产库存已满，等待消费后继续生产

实践见真理了，很好地辅证了，最上面的概念问题。什么，为什么用的notifyAll，不是notify？很好理解，前者唤醒加锁对象上等待的所有线程，后者是单个（没有设置线程优先级，随机唤醒）。