当使用线程来同时运行多个任务时，可以使用锁（互斥）来同步两个任务的行为，从而使得一个任务不会干扰另一个任务，也就是说两个任务在交替的使用某个共享资源，使用互斥可以保证时刻只有一个任务可以访问这项资源。
解决了多线程引起的资源竞争问题，那么我们又该如何实现线程间的彼此协作？使得多个任务可以一起去解决某个问题，也就是说，现在的问题不是线程间的干涉，而是线程间如何协调，因为在这类问题中，某些部分必须在其他部分被解决之前解决。
一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”（what）和“怎么做”（How），在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，在Java语言中实现的简单的办法是让消费者线程不断地循环检查变量是否符合预期，如下面代码所示，在 while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。
while (value != desire) {
Thread.sleep(1000);
}
doSomething();但是上述代码也会带来其他问题
- 难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
- 难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。
所以，我们需要Java内置的等待/通知机制来更好的解决这个问题。实现等待/通知机制的相关方法是所以对象都具有的，因为他们被定义在了Object对象上。
1.概念
等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B 调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而 执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的 关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。（也可以通过Condition类的await(),signal()/signalAll()来实现）
2. 相关API
1.wait()
当对象调用该方法的线程会无限期进入等待状态（或者说在等待着返回，也就是return，类似于网络编程中的ServerSocket对象的accept方法，只有一个客户端建立连接时方法才能结束，更直白的说相当于在wait()方法内部有一个while死循环，循环跳出条件就是这个对象被其他线程唤醒，解释代码如下），并释放对象的锁，只有等待另一个线程的通知或者被中断该方法才会返回，注意！返回之后并不是一定会进入运行状态，而是先变成就绪状态，然后再继续运行。
//当然，内部实现并不是这样，仅仅作为一个比喻
private boolean token=false;
//线程A调用对象的wait1方法，陷入等待
public void wait1(){
while(token==false){
}
return;
}
//线程B调用同一个对象的notify1方法，便可实现唤醒
public void notify1(){
token=true;
}2.wait(long time)，wait(long time,int nanos)
超时等待，等待另一个线程的通知或在等待一段时间后自动方法返回，time是毫秒，nanos是纳秒。
3.notify()
通知一个在该对象上等待的线程，使其从wait()方法返回，而前提是当前线程获取了同一对象的锁。
4.notifyAll()
通知所有在该对象上等待的线程，使其从wait()方法返回。
3.详解
1）为何wait()和notify/notifyAll()方法时放在Object类中而不是Thread类中，这三种方法都是针对线程的功能却作为所有类的通用功能来实现，因为等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法是定义在object类中。既然wait()和notify/notifyAll()必须操作锁，那么wait()和notify/notifyAll()必须处于同步代码块或方法中。（Lock锁中使用Condition来实现）
public class WaitNotify {
static boolean flag = true;
static Object lock = new Object();
public static void main(String[] args) throws Exception {
Thread waitThread = new Thread(new Wait(), "WaitThread");
waitThread.start();
TimeUnit.SECONDS.sleep(1);
Thread notifyThread = new Thread(new Notify(), "NotifyThread");
notifyThread.start();
}
static class Wait implements Runnable {
public void run() {
// 加锁，拥有lock的Monitor
synchronized (lock) {
// 当条件不满足时，继续wait，同时释放了lock的锁
while (flag) {
try {
System.out.println(Thread.currentThread() + " flag is true. wait"
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.wait();
} catch (InterruptedException e) {
}
}
// 条件满足时，完成工作
System.out.println(Thread.currentThread() + " flag is false. running"
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}
}
static class Notify implements Runnable {
public void run() {
// 加锁，拥有lock的Monitor
synchronized (lock) {
// 获取lock的锁，然后进行通知，通知时不会释放lock的锁，
// 直到当前线程释放了lock后，WaitThread才能从wait方法中返回
System.out.println(Thread.currentThread() + " hold lock. notify @ "
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.notifyAll();
flag = false;
}
// 再次加锁
synchronized (lock) {
System.out.println(Thread.currentThread() + " hold lock again. sleep"
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}
}
}2）使用wait()/notify()时的细节：
- 使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
- 调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
- notify()或notifyAll()方法调用后，等待线程不会立即从wait()返回，需要调用notify()或 notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。
- notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll() 方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为 BLOCKED。
- 从wait()方法返回的前提是获得了调用对象的锁。
3）等待/通知机制的经典范式
等待方遵循如下原则：
- 获取对象的锁。
- 如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。
- 条件满足则执行对应的逻辑。
伪代码为：
synchronized(对象) {
while(条件不满足) {
对象.wait();
}
对应的处理逻辑
}
通知方应遵循：
- 获得对象的锁。
- 改变条件。
- 通知所有等待在对象上的线程。
伪代码为：
synchronized(对象) {
改变条件
对象.notifyAll();
}4. 第二种实现方法Lock与Condition
除了使用Object类中的wait()/notify()外，还可以通过Lock与Condition结合使用实现。具体使用与wait()/notify()相似。
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class AwaitAndSignal {
static boolean flag = true;
static Lock lock = new ReentrantLock();
static Condition con=lock.newCondition();
public static void main(String[] args) throws Exception {
Thread AwaitThread = new Thread(new Await(), "AwaitThread");
AwaitThread.start();
TimeUnit.SECONDS.sleep(1);
Thread SignalThread = new Thread(new Signal(), "SignalThread");
SignalThread.start();
}
static class Await implements Runnable {
public void run() {
try{
lock.lock();
while(flag&&!Thread.interrupted()){
try {
System.out.println(Thread.currentThread() + " flag is true. wait"
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
con.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread() + " flag is false. running"
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
}finally {
lock.unlock();
}
}
}
static class Signal implements Runnable {
public void run() {
try{
lock.lock();
System.out.println(Thread.currentThread() + " hold lock. notify"
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
con.signalAll();
flag = false;
}finally {
lock.unlock();
}
// 再次加锁
try{
lock.lock();
System.out.println(Thread.currentThread() + " hold lock again. sleep"
+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
}finally {
lock.unlock();
}
}
}
}
5.Thread.join()方法
如果一个线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(longmillis,int nanos)两个具备超时特性的方法。
public class ThreadMethodJoin {
public static void main(String[] args) throws Exception {
Thread previous = Thread.currentThread();
for (int i = 0; i < 10; i++) {
// 每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回
Thread thread = new Thread(new Domino(previous), String.valueOf(i));
thread.start();
previous = thread;
}
TimeUnit.SECONDS.sleep(5);
System.out.println(Thread.currentThread().getName() + " terminate.");
}
static class Domino implements Runnable {
private Thread thread;
public Domino(Thread thread) {
this.thread = thread;
}
public void run() {
try {
thread.join();
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName() + " terminate.");
}
}
}
