執行緒間通訊

    執行緒與執行緒之間不是獨立的個體，它們彼此之間可以相互通訊與協作。

    執行緒間通訊後，系統之間的互動性會更強大，在大大提交CPU利用率的同時，還會使程式要對各執行緒任務在處理的過程中進行有效的把控和監督。

    學習目錄：

    一、使用wait/notify實現執行緒間的通訊

    二、生產者/消費者模式的實現

    三、方法join的使用

    四、ThreadLocal類的使用

    一、使用wait/notify實現執行緒間的通訊

       1.1 不使用等待/通知機制實現執行緒間通訊：

             執行緒A做i++的操作，執行緒B利用while(true){if(i==5){to do ...}}輪詢去檢測 i 的值，這樣會非常浪費CPU資源。

             如果輪詢時間間隔較短，更浪費CPU資源；如果輪詢時間間隔較長，有可能會取不奧想要得到的資料。

             所以，就需要一種機制來減少CPU的資源浪費，而且還可以實現在多個執行緒間通訊，它就是“wait/notify”機制。

       1.2 等待/通知機制的實現】

            方法wait()的作用是使當前執行程式碼的執行緒進行等待，wait()方法是Object類的方法，該方法是用來將當前執行緒置入“預執行佇列”中，並且在wait()所在的程式碼處停止執行，知道接到通知或被中斷為止。

            wait()方法只能在同步方法中或同步塊中呼叫。如果呼叫wait()時，沒有持有適當的鎖，會丟擲異常。

            wait()方法執行後，當前執行緒釋放鎖，執行緒與其他執行緒競爭重新獲取鎖。

            方法notify()也要在同步方法或同步塊中呼叫，該方法是用來通知那些可能等待該物件的物件鎖的其他執行緒，對其發出通知notify，並使它重新獲取該物件的物件鎖。如果有多個執行緒等待，則有執行緒規劃器隨機挑選出一個呈wait狀態的執行緒。

           在notify()方法後，當前執行緒不會馬上釋放該物件鎖，要等到執行notify()方法的執行緒將程式執行完，也就是退出同步程式碼塊中。

             小結一下：wait()是使執行緒停止執行，而notify使停止的執行緒繼續執行。

        簡單案例

        程式碼清單：

<span style="font-size:18px;">package org.jksoft.thread.Volatile;
/**
 * 測試三：使用wait/notify機制的案例
 * 注意：wait/notify都必須在同步程式碼塊中呼叫。
 * @author mcl
 *
 * 2016-2-20-下午12:01:25
 */
public class Test3 {
	public static void main(String[] args) throws InterruptedException {
		Object lock = new Object();
		MyThread1 t1 = new MyThread1(lock);
		t1.start();
		Thread.sleep(3000);
		MyThread2 t2 = new MyThread2(lock);
		t2.start();
	}
}
class MyThread1 extends Thread{
	private Object lock;
	public MyThread1(Object lock){
		this.lock = lock;
	}
	@Override
	public void run(){
			try {
				synchronized (lock) {
				System.out.println("begin wait   "+System.currentTimeMillis());
				lock.wait();
				System.out.println("end wait     "+System.currentTimeMillis());
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
	}
}
class MyThread2 extends Thread{
	private Object lock;
	public MyThread2(Object lock){
		this.lock = lock;
	}
	@Override
	public void run(){
		synchronized (lock) {
				System.out.println("begin notify "+System.currentTimeMillis());
				lock.notify();
				System.out.println("end notify   "+System.currentTimeMillis());
		}
	}
}</span>

       Java為每一個Object都實現了wait()和notify()方法，他們必須用於同步程式碼塊內。

        notify()方法可以隨機喚醒等待佇列中等待同一共享資源的“一個執行緒”，並使該執行緒退出等待佇列，進入可執行狀態，也就是notify()方法僅通知“一個“執行緒。

       notifyAll()方法可以使所有正在等待佇列中等待同一資源的"全部"執行緒從等待狀態中退出，進入可執行狀態。

      1.3 方法wait()鎖釋放與notify()鎖不釋放。

      1.4 當interrupt方法遇到wait方法

            當執行緒呈wait狀態時，呼叫執行緒物件的interrupt()方法會出現異常。

      1.5  方法wait(long)的使用

            帶一個引數的wait(long)方法的功能是等待某一個時間內是否有執行緒對鎖進行喚醒，如果超過這個時間則自動喚醒。

     1.6 等待wait的條件發生變化

      案例：執行緒r1，r2負責向list集合中移除一個元素，如果list的size為0，則進入堵塞佇列

                 執行緒a負責向list集合中新增一個元素，然後喚醒所有等待在堵塞佇列的所有執行緒。

      程式碼清單：

package org.jksoft.thread.Volatile;

import java.util.ArrayList;
import java.util.List;

/**
 * 測試四：使用wait/notify機制的案例，當wait的等待條件發生改變時 注意：wait/notify都必須在同步程式碼塊中呼叫。
 * 
 * @author mcl
 * 
 *         2016-2-20-下午12:01:25
 */
public class Test4 {
	private static List<String> list = new ArrayList<String>();
	
	public static void main(String[] args) throws InterruptedException {
		String lock = "";
		removeThread r1 = new removeThread(lock);
		r1.start();
		removeThread r2 = new removeThread(lock);
		r2.start();
		Thread.sleep(3000);
		addThread a = new addThread(lock);
		a.start();
	}
	static class addThread extends Thread {
		private String lock;
		public addThread(String lock) {
			this.lock = lock;
		}
		public void run() {
			synchronized (lock) {
				list.add("a");
				lock.notifyAll();
				System.out.println("喚醒所有等待該鎖的執行緒");
			}

		}
	}
	static class removeThread extends Thread {
		private String lock;
		public removeThread(String lock) {
			this.lock = lock;
		}
		public void run() {
			try {
				synchronized (lock) {
					if (list.size() == 0) {
						System.out.println("進入等待喚醒的佇列..."
								+ Thread.currentThread().getName());
						lock.wait();
						System.out.println("等待佇列的執行緒被喚醒..."
								+ Thread.currentThread().getName());
					}
					list.remove(0);
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}
}

        執行結果分析:

         剛開始的時候，list的size為0，所以兩個r執行緒進入堵塞佇列。等到a執行緒向list集合中新增一個元素後，喚醒了r1，r2兩個執行緒。兩個執行緒都去繼續向下執行，都進行list.remove(0)的運算，那麼這樣的話，只有一個元素的list是不能移出兩個的，所以只能丟擲異常。

        問題出現原因：是由於r1,r2兩個執行緒沒有重新去驗證list的size的條件，導致後續結果的異常。

        解決方案：

            將上訴程式碼中，

if (list.size() == 0) {

while (list.size() == 0) { 

         我們再看一下執行結果：這就與我們所期待的結果一致了。