一、简介notify、notifyAll、wait方法
 
——final方法，不能覆盖
 ——这三个方法主要用在多线程程序中
 说明：用到时再补充，先记录

 
wait / notify / noitfyAll
 
作用于同一个对象
官方解释
例子
注意：
wait /notify不管是哪个/哪些线程，只要保证是同一个对象就可以。
调用wait和notify/notifyAll的地方要加上synchronized关键字，不然会报错！参考：[https://www.cnblogs.com/szrs/p/11867805.html](https://www.cnblogs.com/szrs/p/11867805.html)
更加完善/复杂的线程交互（wait/notify），可参考《how tomcat works》第四章源码
 

 
今天发现点java多线程关于wait()/notify/notifyAll()方法的小细节，特此记录以便后面查阅。
 
作用于同一个对象
 
wait()： 迫使当前线程等待。
 notify()/notifyAll()：唤醒在当前对象（this）上正在等待的线程。
 
wait —notify/notifyAll : 就是两个相反的动作，就像 “停止—启动”一样，并且，这两个相反的动作是针对同一个对象的。 比如，将A汽车停止，自然启动也要针对A汽车来启动，而不是B汽车、C汽车。
 
官方解释
 
官方文档也已经说明，“针对同一对象”
 
 
 
例子
 
创建 Road类实现Runnable接口
 
package com.xl.threadinteraction;

public class Road implements Runnable {
	
	private Car car;
	
	
	@Override
	public void run() {
		Car car = this.getCar();
		car.receiveNotify();
	}
	
	
	void startThead() {
		Thread thread002 = new Thread(null,this,"thread002");
		thread002.start();
	}
	

	public Car getCar() {
		return car;
	}


	public void setCar(Car car) {
		this.car = car;
	}
	

}

 
创建Car类实现Runnable接口
 
package com.xl.threadinteraction;

public class Car implements Runnable {
	
	private String color;
	
	private String year;
	
	
	public Car () {
	}
	
	public Car (String year, String color) {
		this.year = year;
		this.color = color;
	}
	

	@Override
	public void run() {
		drive();
		System.out.println("car driving....");
	}

	
	synchronized void drive() {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
	}
	
	synchronized void receiveNotify() {
		notifyAll();
	}
	
	/**
	 * 
	 * @Description getters and setters
	 * @return
	 * @author John Abruzzi
	 * @date   2021年12月3日
	 */
	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public String getYear() {
		return year;
	}

	public void setYear(String year) {
		this.year = year;
	}
}

 
创建启动类
 
package com.xl.threadinteraction;

public class ThreadInteraction {

	public static void main(String[] args) {
		// 创建car对象
		Car car001 = new Car("1982","red");
//		Car car002 = new Car("1900","black");
		
		// 创建线程
		Thread thread001 = new Thread(null,car001,"thread001");
		thread001.start();
//		Thread thread002 = new Thread(null,car002,"thread001");
//		thread002.start();
		
		// 创建road对象
		Road road001 = new Road();
		road001.setCar(car001);
		road001.startThead();
		
	}

}

 
因为无论是wait(）方法，还是notifyAll()方法都是在名为“car001”这个对象上进行调用的，所以是同一个对象，执行结果会打印 “car driving…”
 
 
 假设将启动类中传不同的对象,即是：在car001上调用wait(), 在car002上调用notifyAll, 则执行结果不会有输出。
 
 
 
注意：
 
wait /notify不管是哪个/哪些线程，只要保证是同一个对象就可以。
 
 
调用wait和notify/notifyAll的地方要加上synchronized关键字，不然会报错！参考：https://www.cnblogs.com/szrs/p/11867805.html
 
更加完善/复杂的线程交互（wait/notify），可参考《how tomcat works》第四章源码

1、在java中，每个对象都有两个池，锁(monitor)池和等待池，每个对象都能够被作为“监视器monitor”——指一个拥有一个独占锁
 
 
      wait()/notify()方法定义在Object类中。如果线程要调用对象的wait()方法，必须首先获得该对象的监视器锁，调用wait()之后，当前线程又立即释放掉锁，线程随后进入WAIT_SET（等待池）中。如果线程要调用对象的notify()/notifyAll()方法，也必须先获得对象的监视器锁，调用方法之后，立即释放掉锁，然后处于Wait_set的线程被转移到Entry_set（等锁池）中，去竞争锁资源。The Winner Thread，也就是成功获得了对象的锁的线程，就是对象锁的拥有者，会进入runnable状态。由于需要获得锁之后才能够调用wait()/notify()方法，因此必须将它们放到同步代码块中。 
 
     锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
 
      等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。如果另外的一个线程调用了相同对象的notifyAll()方法，那么处于该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。如果另外的一个线程调用了相同对象的notify()方法，那么仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池.
 
下面是动力节点课程中对于锁池和等待池的说明：
 
在java中，每个对象都有两个池，锁池和等待池。Java平台中，因为有内置锁的机制，每个对象都可以承担锁的功能。Java虚拟机会为每个对象维护两个“队列”（姑且称之为“队列”，尽管它不一定符合数据结构上队列的“先进先出”原则）：一个叫Entry Set（入口集），另外一个叫Wait Set（等待集）。对于任意的对objectX，objectX的Entry Set用于存储等待获取objectX这个锁的所有线程，也就是传说中的锁池，objectX的Wait Set用于存储执行了objectX.wait()/wait(long)的线程，也就是等待池。
 
下面我们来看锁池和等待池的具体介绍：
 
锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
 
等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁(因为wait()方法必须出现在synchronized中，这样自然在执行wait()方法之前线程A就已经拥有了该对象的锁)，同时线程A就进入到了该对象的等待池中。如果另外的一个线程调用了相同对象的notifyAll()方法，那么处于该对象的等待池中的线程就会全部进入该对象的锁池中，准备争夺锁的拥有权。如果另外的一个线程调用了相同对象的notify()方法，那么仅仅有一个处于该对象的等待池中的线程(随机)会进入该对象的锁池。
 
设objectX是任意一个对象，假设有线程A、B、C同时申请objectX这个对象锁，那么由于任意一个时刻只有一个线程能够获得（占用/持有）这个锁，因此除了胜出（即获得了锁）的线程（这里假设是B）外，其他线程（这里就是A和C）都会被暂停（线程的生命周期状态会被调整为BLOCKED）。这些因申请锁而落选的线程就会被存入objectX对应的锁池之中。当objectX被其持有线程（这里就是B）释放时，锁池中的一个任意（注意是“任意”，而不一定是锁池中等待时间最长或者最短的）线程会被唤醒（即线程的生命周期状态变更为RUNNABLE）。这个被唤醒的线程会与其他活跃线程（即不处于锁池之中，且线程的生命周期状态为RUNNABLE的线程）再次抢占objectX。这时，被唤醒的线程如果成功申请到objectX，那么该线程就从锁池中移除。否则，被唤醒的线程仍然会停留在锁池中，并再次被暂停，以等待下次申请锁的机会。
 
      如果有个线程执行了objectX.wait()，那么该线程就会被暂停（线程的生命周期状态会被调整为Waiting），并且会释放掉objectX锁，然后被存入objectX的等待池之中。此时，该线程就被称为objectX的等待线程。当其他线程执行了objectX.notify()/notifyAll()时，等待池中的一个（或者多个，取决于被调用的是notify还是notifyAll方法）任意（注意是“任意”，而不一定是等待池中等待时间最长或者最短的）等待线程会被唤醒，这些被唤醒的线程会被放到锁池中，会与锁池中已经存在的线程以及其他（可能的）活跃线程共同参与抢夺objectX。至于代码中到底是使用notify还是notifyAll方法，这个要根据实际情况来分析。
 
2、wait() ,notifyAll(),notify() 三个方法都是Object类中的方法.
 
3、notify发生死锁的情景
 
package com.tyxh.block;

class OutTurn {
    private boolean isSub = true;
    private int count = 0;

    public synchronized void sub() {
        try {
            while (!isSub) {
                this.wait();
            }
            System.out.println("sub ---- " + count);
            isSub = false;
            this.notify();
        } catch (Exception e) {
            e.printStackTrace();
        }
        count++;

    }

    public synchronized void main() {
        try {
            while (isSub) {
                this.wait();
            }
            System.out.println("main (((((((((((( " + count);
            isSub = true;
            this.notify();
        } catch (Exception e) {
            e.printStackTrace();
        }
        count++;
    }
}
 
 
package com.tyxh.block;

public class LockDemo {
    public static void main(String[] args) {
        // System.out.println("lock");

        final OutTurn ot = new OutTurn();

        for (int j = 0; j < 100; j++) {

            new Thread(new Runnable() {

                public void run() {
                    // try {
                    // Thread.sleep(10);
                    // } catch (InterruptedException e) {
                    // e.printStackTrace();
                    // }
                    for (int i = 0; i < 5; i++) {
                        ot.sub();
                    }
                }
            }).start();

            new Thread(new Runnable() {

                public void run() {
                    // try {
                    // Thread.sleep(10);
                    // } catch (InterruptedException e) {
                    // e.printStackTrace();
                    // }
                    for (int i = 0; i < 5; i++) {
                        ot.main();
                    }
                }
            }).start();
        }

    }
}
 
解释一下原因：
 
     OutTurn类中的sub和main方法都是同步方法，所以多个调用sub和main方法的线程都会处于阻塞状态，等待一个正在运行的线程来唤醒它们。下面分别分析一下使用notify和notifyAll方法唤醒线程的不同之处：
 
     上面的代码使用了notify方法进行唤醒，而notify方法只能唤醒一个线程，其它等待的线程仍然处于wait状态，假设调用sub方法的线程执行完后（即 System.   out  .println( "sub ---- "   +  count  ) 执行完之后），所有的线程都处于等待状态，此时在sub方法中的线程执行了isSub=false语句后又执行了notify方法，这时如果唤醒的是一个sub方法的调度线程，那么while循环等于true，则此唤醒的线程也会处于等待状态，此时所有的线程都处于等待状态，那么也就没有了运行的线程来唤醒它们，这就发生了死锁。
 
     如果使用notifyAll方法来唤醒所有正在等待该锁的线程，那么所有的线程都会处于运行前的准备状态（就是sub方法执行完后，唤醒了所有等待该锁的状态,注：不是wait状态），那么此时，即使再次唤醒一个sub方法调度线程，while循环等于true，唤醒的线程再次处于等待状态，那么还会有其它的线程可以获得锁，进入运行状态。
 
     总结：notify方法很容易引起死锁，除非你根据自己的程序设计，确定不会发生死锁，notifyAll方法则是线程的安全唤醒方法。
 
4、java 为什么wait(),notify(),notifyAll()必须在同步（Synchronized）方法/代码块中调用
 
先回答问题：
 
（1）为什么wait()必须在同步（Synchronized）方法/代码块中调用？
 
答：调用wait()就是释放锁，释放锁的前提是必须要先获得锁，先获得锁才能释放锁。
 
（2）为什么notify(),notifyAll()必须在同步（Synchronized）方法/代码块中调用？
 
答：notify(),notifyAll()是将锁交给含有wait()方法的线程，让其继续执行下去，如果自身没有锁，怎么叫把锁交给其他线程呢；（本质是让处于入口队列的线程竞争锁）
 
下面是正文（详细解释）：
 
之前一直谨记老师教的wait(),notify(),notifyAll()必须要在Synchronized关键中使用，不得其解，现在研究了一下，终于明白了。
 
首先，要明白，每个对象都可以被认为是一个"监视器monitor"，这个监视器由三部分组成（一个独占锁，一个入口队列，一个等待队列）。注意是一个对象只能有一个独占锁，但是任意线程线程都可以拥有这个独占锁。
 
对于对象的非同步方法而言，任意时刻可以有任意个线程调用该方法。（即普通方法同一时刻可以有多个线程调用）
 
对于对象的同步方法而言，只有拥有这个对象的独占锁才能调用这个同步方法。如果这个独占锁被其他线程占用，那么另外一个调用该同步方法的线程就会处于阻塞状态，此线程进入入口队列。
 
若一个拥有该独占锁的线程调用该对象同步方法的wait()方法，则该线程会释放独占锁，并加入对象的等待队列；（为什么使用wait()？希望某个变量被设置之后再执行，notify()通知变量已经被设置。）
 
某个线程调用notify(),notifyAll()方法是将等待队列的线程转移到入口队列，然后让他们竞争锁，所以这个调用线程本身必须拥有锁。

为什么wait必须在synchronized保护的同步代码种使用？
 
首先我们来看看wait方法的源码注释是怎么写的？
 
//wait method should always be used in a loop：
synchronized (ojb) {
	while(condition does not hold)
		obj.wait();
	... //Perform action appropriate to condition
}
//This method should only be called by a thread that is the owner of this object's monitoe.
 
为什么wait必须在synchronized保护的同步代码种使用？
 
首先我们来看看wait方法的源码注释是怎么写的？
 
//wait method should always be used in a loop：
synchronized (ojb) {
	while(condition does not hold)
		obj.wait();
	... //Perform action appropriate to condition
}
//This method should only be called by a thread that is the owner of this object's monitoe.
 
 
 
英文部分的意思是说，在使用 wait 方法时，必须把 wait 方法写在 synchronized 保护的 while代码块中，并始终判断执行条件是否满足，如果满足就往下继续执行，如果不满足就执行 wait 方法，而在执行 wait方法之前，必须先持有对象的 monitor 锁，也就是通常所说的 synchronized 锁。
 
 
那么设计成这样有什么好处呢？
 
我们逆向思考这个问题，如果不要求 wait 方法放在 synchronized 保护的同步代码中使用，而是可以随意调用，那么就有可能写出这样的代码。
 
class BlockingQueue {
	Queue<String> buffer = new LinkList<String>();
	public void give(String data) {
		buffer.add(data);
		nodify();	//Since someone may be waiting in take
	}

	public String take() throws InterruptedException {
		while(buffer.isEmpty()) {
			wait();
		}
		return buffer.remove();
	}
}
 
在代码中可以看到有两个方法，give 方法负责往 buffer 中添加数据，添加完之后执行 notify 方法来唤醒之前等待的线程，而 take 方法负责检查整个 buffer 是否为空，如果为空就进入等待，如果不为空就取出一个数据，这是典型的生产者消费者的思想。
 
但是这段代码并没有受 synchronized 保护，于是便有可能发生以下场景：
 
 
 
首先，消费者线程调用 take 方法并判断 buffer.isEmpty 方法是否返回 true，若为 true 代表buffer是空的，则线程希望进入等待，但是在线程调用 wait 方法之前，就被调度器暂停了，所以此时还没来得及执行 wait 方法。
此时生产者开始运行，执行了整个 give 方法，它往 buffer 中添加了数据，并执行了 notify 方法，但 notify 并没有任何效果，因为消费者线程的 wait 方法没来得及执行，所以没有线程在等待被唤醒。
此时，刚才被调度器暂停的消费者线程回来继续执行 wait 方法并进入了等待。
 
 
虽然刚才消费者判断了 buffer.isEmpty 条件，但真正执行 wait 方法时，之前的 buffer.isEmpty 的结果已经过期了，不再符合最新的场景了，因为这里的“判断-执行”不是一个原子操作，它在中间被打断了，是线程不安全的。
 
假设这时没有更多的生产者进行生产，消费者便有可能陷入无穷无尽的等待，因为它错过了刚才 give 方法内的 notify 的唤醒。
 
我们看到正是因为 wait 方法所在的 take 方法没有被 synchronized 保护，所以它的 while 判断和 wait 方法无法构成原子操作，那么此时整个程序就很容易出错。
 
我们把代码改写成源码注释所要求的被 synchronized 保护的同步代码块的形式，代码如下。
 
public void give(String data) {
	synchronized (this) {
		buffer.add(data);
		notify();
	}
}

public String take() throws InterruptedException {
	synchronized (this) {
		while(buffer.isEmpty()) {
			wait();
		}
		return buffer.remove();
	}
}
 
这样就可以确保 notify 方法永远不会在 buffer.isEmpty 和 wait 方法之间被调用，提升了程序的安全性。
 
另外，wait 方法会释放 monitor 锁，这也要求我们必须首先进入到 synchronized 内持有这把锁。
 
这里还存在一个“虚假唤醒”（spurious wakeup）的问题，线程可能在既没有被notify/notifyAll，也没有被中断或者超时的情况下被唤醒，这种唤醒是我们不希望看到的。虽然在实际生产中，虚假唤醒发生的概率很小，但是程序依然需要保证在发生虚假唤醒的时候的正确性，所以就需要采用while循环的结构。
 
while(condition does not hold)
	obj.wait();
 
这样即便被虚假唤醒了，也会再次检查while里面的条件，如果不满足条件，就会继续wait，也就消除了虚假唤醒的风险。
 
为什么 wait/notify/notifyAll 被定义在 Object 类中，而 sleep 定义在 Thread 类中？
 
因为 Java 中每个对象都有一把称之为 monitor 监视器的锁，由于每个对象都可以上锁，这就要求在对象头中有一个用来保存锁信息的位置。这个锁是对象级别的，而非线程级别的，wait/notify/notifyAll 也都是锁级别的操作，它们的锁属于对象，所以把它们定义在 Object 类中是最合适，因为 Object 类是所有对象的父类。
因为如果把 wait/notify/notifyAll 方法定义在 Thread 类中，会带来很大的局限性，比如一个线程可能持有多把锁，以便实现相互配合的复杂逻辑，假设此时 wait 方法定义在 Thread 类中，如何实现让一个线程持有多把锁呢？又如何明确线程等待的是哪把锁呢？既然我们是让当前线程去等待某个对象的锁，自然应该通过操作对象来实现，而不是操作线程。
 
wait/notify 和 sleep 方法的异同？
 
第三个问题是对比 wait/notify 和 sleep 方法的异同，主要对比 wait 和 sleep 方法，我们先说相同点：
 
它们都可以让线程阻塞。
它们都可以响应 interrupt 中断：在等待的过程中如果收到中断信号，都可以进行响应，并抛出 InterruptedException 异常。
 
但是它们也有很多的不同点：
 
wait 方法必须在 synchronized 保护的代码中使用，而 sleep 方法并没有这个要求。
在同步代码中执行 sleep 方法时，并不会释放 monitor 锁，但执行 wait 方法时会主动释放 monitor 锁。
sleep 方法中会要求必须定义一个时间，时间到期后会主动恢复，而对于没有参数的 wait 方法而言，意味着永久等待，直到被中断或被唤醒才能恢复，它并不会主动恢复。
wait/notify 是 Object 类的方法，而 sleep 是 Thread 类的方法。