1 对象的方法，用于唤醒等待池中的线程，将等待池中的线程唤醒至锁池；
2 notify()随机唤醒等待池中的任意一个线程至锁池，notifyAll()唤醒等待池中所有的线程至锁池

原文见知乎： 

作者：知乎用户 

链接：https://www.zhihu.com/question/37601861/answer/145545371 

来源：知乎

锁池和等待池: 

锁池：假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。

等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池中

notify和notifyAll的区别  

如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。 

当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。 

注意： 

 永远在synchronized的函数或对象里使用wait、notify和notifyAll，不然Java虚拟机会生成 IllegalMonitorStateException。

综上，所谓唤醒线程，另一种解释可以说是将线程由等待池移动到锁池，notifyAll调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。而notify只会唤醒一个线程。有了这些理论基础，后面的notify可能会导致死锁，而notifyAll则不会的例子也就好解释了

您可能已经注意到Object类具有三个最终方法，分别称为wait，notify和notifyAll。这些方法用于线程间通信。Java 5引入了执行程序框架，该执行程序框架为您处理线程间通信，并在内部使用wait，notify和notifyAll。但是您仍然需要对这些方法以及线程间通信如何在Java中使用wait，notify和notifyAll进行基本了解。


什么是wait，notify和notifyAll方法？

wait，notify和notifyAll方法用于允许线程通过访问公共对象彼此通信，或者换句话说，对象可以被视为通过这些方法进行线程间通信的媒介。这些方法需要从同步上下文中调用，否则将抛出java.lang.IllegalMonitorStateException。

同步块的一些背景：

同步块中一次只能进入一个线程
	
线程需要锁定对象才能进入同步块。
	
如果线程A要进入同步块，则线程A必须等待线程B释放它。
让我们对这些方法有一些简要的了解：

wait()：

当您在对象上调用wait方法时，它告诉线程放弃锁并进入睡眠状态，除非并且直到其他线程进入同一监视器并在其上调用notify或notifyAll方法。

notify()：

当您在对象上调用notify方法时，它将唤醒等待该对象的线程之一。因此，如果有多个线程在等待一个对象，它将唤醒其中之一。现在，您一定想知道它将唤醒哪一个。它实际上取决于OS的实现。

notifyAll()：

notifyAll会唤醒所有在该对象上等待的线程，而不是notify会只唤醒其中一个线程，哪个线程会首先唤醒取决于线程优先级和操作系统实现。

让我们借助示例了解它：

1.创建一个名为Book.java的类：


这是Java bean类，线程将在该Java bean类上作用并调用wait和notify方法。





 



 



 




 



			

			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28
			
			
			

			

			
 

			
package org.arpit.java2blog.thread;

			
 

			
public class Book {

			
 

			
String title;

			
boolean isCompleted;

			
 

			
public Book(String title) {

			
  super();

			
  this.title = title;

			
}

			
 

			
public String getTitle() {

			
  return title;

			
}

			
public void setTitle(String title) {

			
  this.title = title;

			
}

			
public boolean isCompleted() {

			
  return isCompleted;

			
}

			
public void setCompleted(boolean isCompleted) {

			
  this.isCompleted = isCompleted;

			
}

			
 

			
}

			
 
			
			
		


2.创建一个名为BookReader.java的类

该线程将等到其他线程调用notify方法，然后再完成其处理。它将首先锁定书本对象，然后从同步块中调用它。因此在本示例中，它将等待BookWriter完成书本。





 



 



 




 



			

			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27
			
			
			

			

			
 

			
package org.arpit.java2blog.thread;

			
 

			
public class BookReader implements Runnable{

			
 

			
Book book;

			
 

			
public BookReader(Book book) {

			
  super();

			
  this.book = book;

			
}

			
 

			
@Override

			
public void run() {

			
  synchronized (book) {

			
   System.out.println(Thread.currentThread().getName()+" is waiting for the book to be completed: "+book.getTitle());

			
   try {

			
    book.wait();

			
   } catch (InterruptedException e) {    

			
    e.printStackTrace();

			
   }

			
   System.out.println(Thread.currentThread().getName()+": Book has been completed now!! you can read it");

			
  }

			
} 

			
 

			
}

			
 
			
			
		


3.创建一个名为BookWriter.java的类

此类将通知正在等待书本对象的线程（如果有notify的话）。一旦调用notify，它将不会放弃锁，它首先完成其同步块。因此，在此示例中，BookWriter将完成书籍并将其通知给BookReaders。

 

 





 



 



 




 



			

			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28

			
29

			
30
			
			
			

			

			
 

			
package org.arpit.java2blog.thread;

			
public class BookWriter implements Runnable{

			
 

			
Book book;

			
 

			
public BookWriter(Book book) {

			
  super();

			
  this.book = book;

			
}

			
 

			
@Override

			
public void run() {

			
  synchronized (book) {

			
   System.out.println("Author is Starting book : " +book.getTitle() );

			
   try {

			
    Thread.sleep(1000);

			
   } catch (InterruptedException e) {

			
    e.printStackTrace();

			
   }

			
   book.setCompleted(true);

			
   System.out.println("Book has been completed now");

			
 

			
   book.notify();

			
   System.out.println("notify one reader");

			
 

			
  } 

			
}

			
}

			
 
			
			
		


4.创建一个类ThreadInterCommunicationMain，java。


这是我们的主类，它将创建上述类的对象并运行它。





 



 



 




 



			

			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28

			
29

			
30

			
31

			
32

			
33

			
34

			
35
			
			
			

			

			
 

			
package org.arpit.java2blog.thread;

			
 

			
public class ThreadInterCommunicationMain {

			
 

			
public static void main(String args[])

			
{

			
  // Book object on which wait and notify method will be called

			
  Book book=new Book("The Alchemist");

			
  BookReader johnReader=new BookReader(book);

			
  BookReader arpitReader=new BookReader(book);

			
 

			
  // BookReader threads which will wait for completion of book

			
  Thread johnThread=new Thread(johnReader,"John");

			
  Thread arpitThread=new Thread(arpitReader,"Arpit");

			
 

			
  arpitThread.start();

			
  johnThread.start();

			
 

			
  // To ensure both readers started waiting for the book

			
  try {

			
   Thread.sleep(3000);

			
  } catch (InterruptedException e) {

			
 

			
   e.printStackTrace();

			
  }

			
  // BookWriter thread which will notify once book get completed

			
  BookWriter bookWriter=new BookWriter(book);

			
  Thread bookWriterThread=new Thread(bookWriter);

			
  bookWriterThread.start();

			
 

			
}

			
 

			
}

			
 
			
			
		




 



在notify()的情况下：


当您运行上述程序时，将得到以下输出：





 



 



 




 



			

			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8
			
			
			

			

			
 

			
Arpit is waiting for the book to be completed: The Alchemist

			
John is waiting for the book to be completed: The Alchemist

			
Author is Starting book : The Alchemist

			
Book has been completed now

			
notify one reader

			
Arpit: Book has been completed now!! you can read it

			
 
			
			
		


 

如果是notifyAll()：可以


将BookWriter类更改为调用book.notifyAll（）。





 



 



 




 



			

			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28

			
29

			
30

			
31

			
32

			
33
			
			
			

			

			
 

			
package org.arpit.java2blog.thread;

			
 

			
public class BookWriter implements Runnable{

			
 

			
Book book;

			
 

			
public BookWriter(Book book) {

			
  super();

			
  this.book = book;

			
}

			
 

			
@Override

			
public void run() {

			
  synchronized (book) {

			
   System.out.println("Author is Starting book : " +book.getTitle() );

			
   try {

			
    Thread.sleep(1000);

			
   } catch (InterruptedException e) {

			
    // TODO Auto-generated catch block

			
    e.printStackTrace();

			
   }

			
   book.setCompleted(true);

			
   System.out.println("Book has been completed now");

			
 

			
   book.notifyAll();

			
   System.out.println("notify readers");

			
 

			
  }

			
}

			
 

			
}

			
 
			
			
		


当您运行上述程序时，将得到以下输出：


 



			

			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9
			
			
			

			

			
 

			
Arpit is waiting for the book to be completed: The Alchemist

			
John is waiting for the book to be completed: The Alchemist

			
Author is Starting book : The Alchemist

			
Book has been completed now

			
notify readers

			
John: Book has been completed now!! you can read it

			
Arpit: Book has been completed now!! you can read it

			
 
			
			
		


如果是notifyAll（），它将通知所有正在等待该对象的线程。

文章目录
场景
分析
例子
经典java线程状态流转图

场景

调用wait的线程的唤醒，一般通过notify和notifyAll,但是两者之间有什么区别呢？

分析

线程调用synchronized方法或者synchronized代码块需要获取对象锁，如果没有获取则进入锁池
线程调用wait方法进入等待池，此时可以通过锁对象调用 notify,notifyAll方法（第三方线程获取锁对象的synchronized的方法中释放），释放等待池线程进入锁池。
notify只释放一个等待池中的线程，优先级的高的机会大些。而notifyAll则释放等待池中所有的线程.

例子

使用notify方法，线程T2处于死锁状态

public class ThreadWaitAndNotifyDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(ThreadWaitAndNotifyDemo::sayHelloWorld);
        thread.setName("T1");
        thread.start();


        Thread thread1 = new Thread(ThreadWaitAndNotifyDemo::sayHelloWorld);
        thread1.setName("T2");
        thread1.start();


        // 调用notify方法的对象必须和wait是同一个
        Object monitor = ThreadWaitAndNotifyDemo.class;
        synchronized (monitor) {
            monitor.notify();
        }
        
//        thread.join();         // 等待线程结束
        System.out.println("Hello next ------->");

    }

    private static void sayHelloWorld()
    {
        Object monitor = ThreadWaitAndNotifyDemo.class;
        synchronized (monitor) {
            try {
                System.out.printf("线程【%s】<--------------->进入等待状态 \n", Thread.currentThread().getName());
                monitor.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.printf("线程[%s] 恢复执行: <==============> Hello World!\n", Thread.currentThread().getName());
        }
    }
}


线程【T1】<--------------->进入等待状态 
线程【T2】<--------------->进入等待状态 
Hello next ------->
线程[T1] 恢复执行: <==============> Hello World!

经典java线程状态流转图