引言：
多线程应用中通常存在线程间的交流问题。java中线程的通信主要体现在几个方法的使用上。
一、涉及到三个方法:
wait()
- 一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器**(注意：这点与sleep()不同，sleep()让线程进入阻塞状态但是不释放锁，并且sleep()是Thread类中的静态方法，而wait()是Object类中的final方法)**。令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
- 在当前线程中调用方法： 对象名.wait()
- 使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify(或notifyAll) 为止。
- 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
- 调用此方法后，当前线程将释放对象监控权 ，然后进入等待
- 在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。
notify()
- 一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。即，唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
- 在当前线程中调用方法： 对象名.notify()
- 功能：唤醒等待该对象监控权的一个/所有线程。
- 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
notifyAll()
- 一旦执行此方法，就会唤醒所有被wait的线程。即，唤醒正在排队等待资源的所有线程结束等待
- 在当前线程中调用方法： 对象名.notify()
- 功能：唤醒等待该对象监控权的一个/所有线程。
- 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
二、说明:
- wait()，notify()，notifyAll()三个方法必须使用在cynchronized代码块或synchronized方法中。不能再Lock中使用，言外之意Lock中实现线程的通信不是同过wait()，notify()，notifyAll()来实现的。
- wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常
- 因为这三个方法必须由锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
三、sleep()和wait()的异同（经典面试题
- 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
- 不同点：
- 1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
- 2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中调用
- 3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
四、线程通信的举例：
- 使用两个线程打印 1-100。线程1，线程2，交替打印
class Number implements Runnable {
private int number = 1;
@Override
public void run() {
while (true) {
synchronized (this) {
//唤醒被wait的一个优先级最高的线程结束等待
notify();//this.notify()
if (number <= 100) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": " + number);
number++;
try {
//使得调用如下wait()方法的线程进入阻塞状态，并且会释放同步监视器（同步锁），这一点与sleep()不同
wait();//this.wait()
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}- 生产者/消费者问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
分析：
- 是否是多线程问题？是，生产者线程，消费者线程
- 是否有共享数据？是，店员（或产品）
- 如何解决线程的安全问题？同步机制，有三种方法。同步代码块，同步方法，Lock锁
- 是否涉及线程的通信？是
/*店员*/
class Clerk {
private int productCount = 0;
//生产产品
public synchronized void produceProduct() {
if (productCount < 20) {
productCount++;
System.out.println(Thread.currentThread().getName() + "：开始生产第" + productCount + "个产品");
//生产者生产出了产品就可以通知等待的消费者购买
notifyAll();//this.notifyAll()
} else {
//等待
try {
wait();//this.wait()
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消费产品
public synchronized void consumeProduct() {
if (productCount > 0) {
System.out.println(Thread.currentThread().getName() + "：开始消费第" + productCount + "个产品");
productCount--;
//消费者消费了一个产品就能通知等待的生产者继续生产
notifyAll();//this.notifyAll()
} else {
//等待
try {
wait();//this.wait()
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/*生产者*/
class Producer extends Thread {
private Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + "：开始生产产品......");
while (true) {
try {
sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
/*消费者*/
class Consumer extends Thread {
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + "：开始消费产品......");
while (true) {
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();//店员，被生产者和消费者共用
Producer p1 = new Producer(clerk);
p1.setName("生产者1");
Consumer c1 = new Consumer(clerk);
c1.setName("消费者1");
Consumer c2 = new Consumer(clerk);
c2.setName("消费者2");
p1.start();
c1.start();
c2.start();
}
}
