一、等待/通知機制

 線上程互動中經常需要對其進行一些控制，希望人為地能夠讓執行緒按理想路線發展，在滿足某條件時進行執行操作而發生變化時，停止等待。

1、 使用sleep 

在 if ( ) { } else { }  中使用sleep 對執行緒進行停止等待一段時間。   弊端：正常情況下 無法客觀預知需要等待的時間，在刻意睡眠一段時間後 很可能發現 依舊不適合由此執行緒執行之後的操作，或者睡眠過久。

2、 使用 while + sleep   迴圈判斷條件 使其睡眠    弊端：雖然能加快判斷條件的變化，但依舊難以確保及時性，會造成無端浪費。

3、wait +notify ：在某條件發生情況下，執行緒A呼叫物件O 的wait() 方法進入等待狀態，當執行緒B呼叫物件O的notify() 或者notifyAll()方法後，執行緒A會接受通知，從其wait方法返回，執行後續操作。

java.lang.Obejct  :

notify()  通知一個在物件上等待的執行緒，使其從wait方法返回（前提是該執行緒獲取到物件的鎖）

notifyAll() 通知所有等待在該物件上的執行緒 （注意，notify等通知時 不會釋放當前物件鎖）

wait()  呼叫該方法的執行緒進入Waiting狀態，只有被中斷或者由其他執行緒通知喚醒才能繼續（wait會導致執行緒釋放物件鎖）

wait(long) 超時等待一段時間，等待xx毫秒，若沒有收到通知 則超時返回

wait(long,int)超時精確到納秒

例：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class WaitAndNotify {
	static boolean flag=true;
	static Object lock =new Object();
	public static void main(String[] args) throws InterruptedException {
		Thread waitThread=new Thread(new Wait(),"waitThread");
		waitThread.start();
		TimeUnit.SECONDS.sleep(2);
		Thread notifyThread=new Thread(new Notify(),"notifyThread");
		notifyThread.start();
	}
static class Wait implements Runnable{
	@Override
	public void run() {
		synchronized (lock) {
			//同步程式碼塊
			while (flag) {
				try {
					System.out.println(Thread.currentThread().getName()+" flag=true. 
 
[email protected]"+
							new SimpleDateFormat("HH:mm:ss").format(new Date()));
					lock.wait();<span style="white-space:pre">	</span>System.out.println("啊啊？");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			//跳出while時
			System.out.println(Thread.currentThread().getName()+" flag=false. 
 
[email protected]"+
					new SimpleDateFormat("HH:mm:ss").format(new Date()));
		}
	}
 }
static class Notify implements Runnable{
	@Override
	public void run() {
		synchronized (lock) {
			//獲取lock物件鎖，然後通知喚醒
			System.out.println(Thread.currentThread().getName()+" hold lock. [email protected]"+
					new SimpleDateFormat("HH:mm:ss").format(new Date()));
			lock.notifyAll();
			flag=false;
			try {
				Thread.sleep(3000);//notify之後執行緒睡眠3秒，驗證Wait類不能馬上輸出“啊啊？”
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} //同步程式碼塊結束後 釋放鎖
		synchronized (lock) {
			//再次加鎖
			System.out.println(Thread.currentThread().getName()+" hold lock again. @"+
					new SimpleDateFormat("HH:mm:ss").format(new Date()));
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
}

waitThread flag=true. [email protected]:00:44
notifyThread hold lock. [email protected]:00:46
notifyThread hold lock again. @16:00:49
啊啊？
waitThread flag=false. [email protected]:00:51

waitThread 獲取到lock物件鎖，之後呼叫wait()方法進入等待佇列，而同時會釋放掉物件鎖，狀態為Waiting。  notifyThread獲取lock物件鎖後呼叫notify()方法通知一個等待執行緒（本例中僅一個等待執行緒），將其移到同步佇列，然後繼續執行自己的程式碼，當釋放掉lock物件鎖後，waitThread執行緒才有可能重新獲取lock並執行先前未完成的程式碼。   藉助《Java併發程式設計的藝術》中一圖：

注意：

1）wait() notify() notifyAll() 等使用時 需要先對呼叫的物件加鎖獲取。

2）wait()之後 執行緒由Running轉變為Waiting 將會把當前執行緒防止到物件的等待佇列。

4）notify()方法將等待佇列中的一個等待執行緒從其中移到同步佇列中，而notifyAll()方法則是喚醒等待佇列中的所有執行緒，全部移到同步佇列，將Waiting改為Blocked

等待方：①.獲取物件鎖 ②.若條件不滿足則呼叫物件wait()，被通知後要重新判斷條件（可能會偽喚醒）③.滿足條件後執行後續操作

通知方：①.獲取物件鎖 ②.改變條件 ③.通知等待的執行緒

二、中斷及join()

interrupt()只是改變中斷狀態而已. interrupt()不會中斷一個正在執行的執行緒。這一方法實際上完成的是，給受阻塞的執行緒丟擲一箇中斷訊號，這樣受阻執行緒就得以退出阻塞的狀態。如果執行緒被Object.wait, Thread.join和Thread.sleep三種方法之一阻塞，它將接收到一箇中斷異常（InterruptedException），從而提早地終結被阻塞狀態。

join() 含義：若執行緒A執行某thread執行緒的join(),那麼當前執行緒A等待thread執行緒終止之後才能從join()返回

例： 每個執行緒呼叫前一個執行緒的join()  按順序結束操作。

import java.util.concurrent.TimeUnit;

public class Test2 {
	public static void main(String[] args) throws InterruptedException {
		Thread[] myThreads =new Thread[5];
		Thread previous=Thread.currentThread();
		for(int i=0;i<5;i++){
			myThreads[i]=new Thread(new Runner(previous),i+1+" Thread");
			myThreads[i].start();
			previous=myThreads[i];
		}
//		TimeUnit.SECONDS.sleep(3);//main sleep 3s
//		myThreads[3].interrupt();
		TimeUnit.SECONDS.sleep(3);//main sleep 3s
		System.out.println(Thread.currentThread().getName()+" terminate");
	}
 static class Runner implements Runnable{
	 private Thread aThread;
	 public Runner( Thread aThread) {
		this.aThread=aThread;
	}
	@Override
	public void run() {
		try {
			aThread.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+" terminate");
	}
 }
}

main terminate
1 Thread terminate
2 Thread terminate
3 Thread terminate
4 Thread terminate
5 Thread terminate

再結束mian 1 2 3   注：由於執行緒一直執行，在報錯的同時，已經在輸出4的語句

java.lang.InterruptedException
4 Thread terminate
	at java.lang.Object.wait(Native Method)
	at java.lang.Thread.join(Thread.java:1249)
	at java.lang.Thread.join(Thread.java:1323)
	at Test2$Runner.run(Test2.java:25)
	at java.lang.Thread.run(Thread.java:745)
5 Thread terminate
main terminate
1 Thread terminate
2 Thread terminate
3 Thread terminate