為什麼需要併發

併發其實是一種解耦合的策略，它幫助我們把做什麼（目標）和什麼時候做（時機）分開。這樣做可以明顯改進應用程式的吞吐量（獲得更多的CPU排程時間）和結構（程式有多個部分在協同工作）。做過Java Web開發的人都知道，Java Web中的Servlet程式在Servlet容器的支援下采用單例項多執行緒的工作模式，Servlet容器為你處理了併發問題。

誤解和正解

最常見的對併發程式設計的誤解有以下這些：

併發總能改進效能（併發在CPU有很多空閒時間時能明顯改程式序的效能，但當執行緒數量較多的時候，執行緒間頻繁的排程切換反而會讓系統的效能下降）
編寫併發程式無需修改原有的設計（目的與時機的解耦往往會對系統結構產生巨大的影響）
在使用Web或EJB容器時不用關注併發問題（只有瞭解了容器在做什麼，才能更好的使用容器）

下面的這些說法才是對併發客觀的認識：

編寫併發程式會在程式碼上增加額外的開銷
正確的併發是非常複雜的，即使對於很簡單的問題
併發中的缺陷因為不易重現也不容易被發現
併發往往需要對設計策略從根本上進行修改

併發程式設計的原則和技巧

單一職責原則

分離併發相關程式碼和其他程式碼（併發相關程式碼有自己的開發、修改和調優生命週期）。

限制資料作用域

兩個執行緒修改共享物件的同一欄位時可能會相互干擾，導致不可預期的行為，解決方案之一是構造臨界區，但是必須限制臨界區的數量。

使用資料副本

資料副本是避免共享資料的好方法，複製出來的物件只是以只讀的方式對待。Java 5的java.util.concurrent包中增加一個名為CopyOnWriteArrayList的類，它是List介面的子型別，所以你可以認為它是ArrayList的執行緒安全的版本，它使用了寫時複製的方式建立資料副本進行操作來避免對共享資料併發訪問而引發的問題。

執行緒應儘可能獨立

讓執行緒存在於自己的世界中，不與其他執行緒共享資料。有過Java Web開發經驗的人都知道，Servlet就是以單例項多執行緒的方式工作，和每個請求相關的資料都是透過Servlet子類的service方法（或者是doGet或doPost方法）的引數傳入的。只要Servlet中的程式碼只使用區域性變數，Servlet就不會導致同步問題。Spring MVC的控制器也是這麼做的，從請求中獲得的物件都是以方法的引數傳入而不是作為類的成員，很明顯Struts 2的做法就正好相反，因此Struts 2中作為控制器的Action類都是每個請求對應一個例項。

Java 5以前的併發程式設計

Java的執行緒模型建立在搶佔式執行緒排程的基礎上，也就是說：

所有執行緒可以很容易的共享同一程式中的物件。
能夠引用這些物件的任何執行緒都可以修改這些物件。
為了保護資料，物件可以被鎖住。

Java基於執行緒和鎖的併發過於底層，而且使用鎖很多時候都是很萬惡的，因為它相當於讓所有的併發都變成了排隊等待。
在Java 5以前，可以用synchronized關鍵字來實現鎖的功能，它可以用在程式碼塊和方法上，表示在執行整個程式碼塊或方法之前執行緒必須取得合適的鎖。對於類的非靜態方法（成員方法）而言，這意味這要取得物件例項的鎖，對於類的靜態方法（類方法）而言，要取得類的Class物件的鎖，對於同步程式碼塊，程式設計師可以指定要取得的是那個物件的鎖。
不管是同步程式碼塊還是同步方法，每次只有一個執行緒可以進入，如果其他執行緒試圖進入（不管是同一同步塊還是不同的同步塊），JVM會將它們掛起（放入到等鎖池中）。這種結構在併發理論中稱為臨界區（critical section）。這裡我們可以對Java中用synchronized實現同步和鎖的功能做一個總結：

只能鎖定物件，不能鎖定基本資料型別
被鎖定的物件陣列中的單個物件不會被鎖定
同步方法可以視為包含整個方法的synchronized(this) { … }程式碼塊
靜態同步方法會鎖定它的Class物件
內部類的同步是獨立於外部類的
synchronized修飾符並不是方法簽名的組成部分，所以不能出現在介面的方法宣告中
非同步的方法不關心鎖的狀態，它們在同步方法執行時仍然可以得以執行
synchronized實現的鎖是可重入的鎖。

在JVM內部，為了提高效率，同時執行的每個執行緒都會有它正在處理的資料的快取副本，當我們使用synchronzied進行同步的時候，真正被同步的是在不同執行緒中表示被鎖定物件的記憶體塊（副本資料會保持和主記憶體的同步，現在知道為什麼要用同步這個詞彙了吧），簡單的說就是在同步塊或同步方法執行完後，對被鎖定的物件做的任何修改要在釋放鎖之前寫回到主記憶體中；在進入同步塊得到鎖之後，被鎖定物件的資料是從主記憶體中讀出來的，持有鎖的執行緒的資料副本一定和主記憶體中的資料檢視是同步的。
在Java最初的版本中，就有一個叫volatile的關鍵字，它是一種簡單的同步的處理機制，因為被volatile修飾的變數遵循以下規則：

變數的值在使用之前總會從主記憶體中再讀取出來。
對變數值的修改總會在完成之後寫回到主記憶體中。

使用volatile關鍵字可以在多執行緒環境下預防編譯器不正確的最佳化假設（編譯器可能會將在一個執行緒中值不會發生改變的變數最佳化成常量），但只有修改時不依賴當前狀態（讀取時的值）的變數才應該宣告為volatile變數。
不變模式也是併發程式設計時可以考慮的一種設計。讓物件的狀態是不變的，如果希望修改物件的狀態，就會建立物件的副本並將改變寫入副本而不改變原來的物件，這樣就不會出現狀態不一致的情況，因此不變物件是執行緒安全的。Java中我們使用頻率極高的String類就採用了這樣的設計。如果對不變模式不熟悉，可以閱讀閻宏博士的《Java與模式》一書的第34章。說到這裡你可能也體會到final關鍵字的重要意義了。

Java 5的併發程式設計

不管今後的Java向著何種方向發展或者滅忙，Java 5絕對是Java發展史中一個極其重要的版本，這個版本提供的各種語言特性我們不在這裡討論（有興趣的可以閱讀我的另一篇文章《Java的第20年：從Java版本演進看程式設計技術的發展》），但是我們必須要感謝Doug Lea在Java 5中提供了他里程碑式的傑作java.util.concurrent包，它的出現讓Java的併發程式設計有了更多的選擇和更好的工作方式。Doug Lea的傑作主要包括以下內容：

更好的執行緒安全的容器
執行緒池和相關的工具類
可選的非阻塞解決方案
顯示的鎖和訊號量機制
下面我們對這些東西進行一一解讀。

原子類

Java 5中的java.util.concurrent包下面有一個atomic子包，其中有幾個以Atomic打頭的類，例如AtomicInteger和AtomicLong。它們利用了現代處理器的特性，可以用非阻塞的方式完成原子操作，程式碼如下所示：

/**
 ID序列生成器
*/
public class IdGenerator {
    private final AtomicLong sequenceNumber = new AtomicLong(0);
    public long next() {
        return sequenceNumber.getAndIncrement(); 
    }
}

顯示鎖

基於synchronized關鍵字的鎖機制有以下問題：

鎖只有一種型別，而且對所有同步操作都是一樣的作用
鎖只能在程式碼塊或方法開始的地方獲得，在結束的地方釋放
執行緒要麼得到鎖，要麼阻塞，沒有其他的可能性

Java 5對鎖機制進行了重構，提供了顯示的鎖，這樣可以在以下幾個方面提升鎖機制：

可以新增不同型別的鎖，例如讀取鎖和寫入鎖
可以在一個方法中加鎖，在另一個方法中解鎖
可以使用tryLock方式嘗試獲得鎖，如果得不到鎖可以等待、回退或者乾點別的事情，當然也可以在超時之後放棄操作

顯示的鎖都實現了java.util.concurrent.Lock介面，主要有兩個實現類：

ReentrantLock - 比synchronized稍微靈活一些的重入鎖
ReentrantReadWriteLock - 在讀操作很多寫操作很少時效能更好的一種重入鎖

對於如何使用顯示鎖，可以參考我的Java面試系列文章《Java面試題集51-70》中第60題的程式碼。只有一點需要提醒，解鎖的方法unlock的呼叫最好能夠在finally塊中，因為這裡是釋放外部資源最好的地方，當然也是釋放鎖的最佳位置，因為不管正常異常可能都要釋放掉鎖來給其他執行緒以執行的機會。

CountDownLatch

CountDownLatch是一種簡單的同步模式，它讓一個執行緒可以等待一個或多個執行緒完成它們的工作從而避免對臨界資源併發訪問所引發的各種問題。下面借用別人的一段程式碼（我對它做了一些重構）來演示CountDownLatch是如何工作的。

import java.util.concurrent.CountDownLatch;
/**
 * 工人類
 * @author 駱昊
 *
 */
class Worker {
    private String name;        // 名字
    private long workDuration;  // 工作持續時間
    /**
     * 構造器
     */
    public Worker(String name, long workDuration) {
        this.name = name;
        this.workDuration = workDuration;
    }
    /**
     * 完成工作
     */
    public void doWork() {
        System.out.println(name + " begins to work...");
        try {
            Thread.sleep(workDuration); // 用休眠模擬工作執行的時間
        } catch(InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println(name + " has finished the job...");
    }
}
/**
 * 測試執行緒
 * @author 駱昊
 *
 */
class WorkerTestThread implements Runnable {
    private Worker worker;
    private CountDownLatch cdLatch;
    public WorkerTestThread(Worker worker, CountDownLatch cdLatch) {
        this.worker = worker;
        this.cdLatch = cdLatch;
    }
    @Override
    public void run() {
        worker.doWork();        // 讓工人開始工作
        cdLatch.countDown();    // 工作完成後倒數計時次數減1
    }
}
class CountDownLatchTest {
    private static final int MAX_WORK_DURATION = 5000;  // 最大工作時間
    private static final int MIN_WORK_DURATION = 1000;  // 最小工作時間
    // 產生隨機的工作時間
    private static long getRandomWorkDuration(long min, long max) {
        return (long) (Math.random() * (max - min) + min);
    }
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(2);   // 建立倒數計時閂並指定倒數計時次數為2
        Worker w1 = new Worker("駱昊", getRandomWorkDuration(MIN_WORK_DURATION, MAX_WORK_DURATION));
        Worker w2 = new Worker("王大錘", getRandomWorkDuration(MIN_WORK_DURATION, MAX_WORK_DURATION));
        new Thread(new WorkerTestThread(w1, latch)).start();
        new Thread(new WorkerTestThread(w2, latch)).start();
        try {
            latch.await();  // 等待倒數計時閂減到0
            System.out.println("All jobs have been finished!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ConcurrentHashMap

ConcurrentHashMap是HashMap在併發環境下的版本，大家可能要問，既然已經可以透過Collections.synchronizedMap獲得執行緒安全的對映型容器，為什麼還需要ConcurrentHashMap呢？因為透過Collections工具類獲得的執行緒安全的HashMap會在讀寫資料時對整個容器物件上鎖，這樣其他使用該容器的執行緒無論如何也無法再獲得該物件的鎖，也就意味著要一直等待前一個獲得鎖的執行緒離開同步程式碼塊之後才有機會執行。實際上，HashMap是透過雜湊函式來確定存放鍵值對的桶（桶是為了解決雜湊衝突而引入的），修改HashMap時並不需要將整個容器鎖住，只需要鎖住即將修改的“桶”就可以了。HashMap的資料結構如下圖所示。

此外，ConcurrentHashMap還提供了原子操作的方法，如下所示：

putIfAbsent：如果還沒有對應的鍵值對對映，就將其新增到HashMap中。
remove：如果鍵存在而且值與當前狀態相等（equals比較結果為true），則用原子方式移除該鍵值對對映
replace：替換掉對映中元素的原子操作

CopyOnWriteArrayList

CopyOnWriteArrayList是ArrayList在併發環境下的替代品。CopyOnWriteArrayList透過增加寫時複製語義來避免併發訪問引起的問題，也就是說任何修改操作都會在底層建立一個列表的副本，也就意味著之前已有的迭代器不會碰到意料之外的修改。這種方式對於不要嚴格讀寫同步的場景非常有用，因為它提供了更好的效能。記住，要儘量減少鎖的使用，因為那勢必帶來效能的下降（對資料庫中資料的併發訪問不也是如此嗎？如果可以的話就應該放棄悲觀鎖而使用樂觀鎖），CopyOnWriteArrayList很明顯也是透過犧牲空間獲得了時間（在計算機的世界裡，時間和空間通常是不可調和的矛盾，可以犧牲空間來提升效率獲得時間，當然也可以透過犧牲時間來減少對空間的使用）。

可以透過下面兩段程式碼的執行狀況來驗證一下CopyOnWriteArrayList是不是執行緒安全的容器。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class AddThread implements Runnable {
    private List<Double> list;
    public AddThread(List<Double> list) {
        this.list = list;
    }
    @Override
    public void run() {
        for(int i = 0; i < 10000; ++i) {
            list.add(Math.random());
        }
    }
}
public class Test05 {
    private static final int THREAD_POOL_SIZE = 2;
    public static void main(String[] args) {
        List<Double> list = new ArrayList<>();
        ExecutorService es = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
        es.execute(new AddThread(list));
        es.execute(new AddThread(list));
        es.shutdown();
    }
}

上面的程式碼會在執行時產生ArrayIndexOutOfBoundsException，試一試將上面程式碼25行的ArrayList換成CopyOnWriteArrayList再重新執行。

List<Double> list = new CopyOnWriteArrayList<>();

Queue

佇列是一個無處不在的美妙概念，它提供了一種簡單又可靠的方式將資源分發給處理單元（也可以說是將工作單元分配給待處理的資源，這取決於你看待問題的方式）。實現中的併發程式設計模型很多都依賴佇列來實現，因為它可以線上程之間傳遞工作單元。
Java 5中的BlockingQueue就是一個在併發環境下非常好用的工具，在呼叫put方法向佇列中插入元素時，如果佇列已滿，它會讓插入元素的執行緒等待佇列騰出空間；在呼叫take方法從佇列中取元素時，如果佇列為空，取出元素的執行緒就會阻塞。

可以用BlockingQueue來實現生產者-消費者併發模型（下一節中有介紹），當然在Java 5以前也可以透過wait和notify來實現執行緒排程，比較一下兩種程式碼就知道基於已有的併發工具類來重構併發程式碼到底好在哪裡了。

- 基於wait和notify的實現

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 公共常量
 * @author 駱昊
 *
 */
class Constants {
    public static final int MAX_BUFFER_SIZE = 10;
    public static final int NUM_OF_PRODUCER = 2;
    public static final int NUM_OF_CONSUMER = 3;
}
/**
 * 工作任務
 * @author 駱昊
 *
 */
class Task {
    private String id;  // 任務的編號
    public Task() {
        id = UUID.randomUUID().toString();
    }
    @Override
    public String toString() {
        return "Task[" + id + "]";
    }
}
/**
 * 消費者
 * @author 駱昊
 *
 */
class Consumer implements Runnable {
    private List<Task> buffer;
    public Consumer(List<Task> buffer) {
        this.buffer = buffer;
    }
    @Override
    public void run() {
        while(true) {
            synchronized(buffer) {
                while(buffer.isEmpty()) {
                    try {
                        buffer.wait();
                    } catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Task task = buffer.remove(0);
                buffer.notifyAll();
                System.out.println("Consumer[" + Thread.currentThread().getName() + "] got " + task);
            }
        }
    }
}
/**
 * 生產者
 * @author 駱昊
 *
 */
class Producer implements Runnable {
    private List<Task> buffer;
    public Producer(List<Task> buffer) {
        this.buffer = buffer;
    }
    @Override
    public void run() {
        while(true) {
            synchronized (buffer) {
                while(buffer.size() >= Constants.MAX_BUFFER_SIZE) {
                    try {
                        buffer.wait();
                    } catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Task task = new Task();
                buffer.add(task);
                buffer.notifyAll();
                System.out.println("Producer[" + Thread.currentThread().getName() + "] put " + task);
            }
        }
    }
}
public class Test06 {
    public static void main(String[] args) {
        List<Task> buffer = new ArrayList<>(Constants.MAX_BUFFER_SIZE);
        ExecutorService es = Executors.newFixedThreadPool(Constants.NUM_OF_CONSUMER + Constants.NUM_OF_PRODUCER);
        for(int i = 1; i <= Constants.NUM_OF_PRODUCER; ++i) {
            es.execute(new Producer(buffer));
        }
        for(int i = 1; i <= Constants.NUM_OF_CONSUMER; ++i) {
            es.execute(new Consumer(buffer));
        }
    }
}

- 基於BlockingQueue的實現

import java.util.UUID;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
/**
 * 公共常量
 * @author 駱昊
 *
 */
class Constants {
    public static final int MAX_BUFFER_SIZE = 10;
    public static final int NUM_OF_PRODUCER = 2;
    public static final int NUM_OF_CONSUMER = 3;
}
/**
 * 工作任務
 * @author 駱昊
 *
 */
class Task {
    private String id;  // 任務的編號
    public Task() {
        id = UUID.randomUUID().toString();
    }
    @Override
    public String toString() {
        return "Task[" + id + "]";
    }
}
/**
 * 消費者
 * @author 駱昊
 *
 */
class Consumer implements Runnable {
    private BlockingQueue<Task> buffer;
    public Consumer(BlockingQueue<Task> buffer) {
        this.buffer = buffer;
    }
    @Override
    public void run() {
        while(true) {
            try {
                Task task = buffer.take();
                System.out.println("Consumer[" + Thread.currentThread().getName() + "] got " + task);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
/**
 * 生產者
 * @author 駱昊
 *
 */
class Producer implements Runnable {
    private BlockingQueue<Task> buffer;
    public Producer(BlockingQueue<Task> buffer) {
        this.buffer = buffer;
    }
    @Override
    public void run() {
        while(true) {
            try {
                Task task = new Task();
                buffer.put(task);
                System.out.println("Producer[" + Thread.currentThread().getName() + "] put " + task);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Test07 {
    public static void main(String[] args) {
        BlockingQueue<Task> buffer = new LinkedBlockingQueue<>(Constants.MAX_BUFFER_SIZE);
        ExecutorService es = Executors.newFixedThreadPool(Constants.NUM_OF_CONSUMER + Constants.NUM_OF_PRODUCER);
        for(int i = 1; i <= Constants.NUM_OF_PRODUCER; ++i) {
            es.execute(new Producer(buffer));
        }
        for(int i = 1; i <= Constants.NUM_OF_CONSUMER; ++i) {
            es.execute(new Consumer(buffer));
        }
    }
}

使用BlockingQueue後程式碼優雅了很多。

併發模型

在繼續下面的探討之前，我們還是重溫一下幾個概念：

概念和解釋
臨界資源：併發環境中有著固定數量的資源
互斥：對資源的訪問是排他式的
飢餓：一個或一組執行緒長時間或永遠無法取得進展
死鎖：兩個或多個執行緒相互等待對方結束
活鎖：想要執行的執行緒總是發現其他的執行緒正在執行以至於長時間或永遠無法執行

重溫了這幾個概念後，我們可以探討一下下面的幾種併發模型。

生產者-消費者

一個或多個生產者建立某些工作並將其置於緩衝區或佇列中，一個或多個消費者會從佇列中獲得這些工作並完成之。這裡的緩衝區或佇列是臨界資源。當緩衝區或佇列放滿的時候，生產這會被阻塞；而緩衝區或佇列為空的時候，消費者會被阻塞。生產者和消費者的排程是透過二者相互交換訊號完成的。

讀者-寫者

當存在一個主要為讀者提供資訊的共享資源，它偶爾會被寫者更新，但是需要考慮系統的吞吐量，又要防止飢餓和陳舊資源得不到更新的問題。在這種併發模型中，如何平衡讀者和寫者是最困難的，當然這個問題至今還是一個被熱議的問題，恐怕必須根據具體的場景來提供合適的解決方案而沒有那種放之四海而皆準的方法（不像我在國內的科研文獻中看到的那樣）。

哲學家進餐

1965年，荷蘭電腦科學家圖靈獎得主Edsger Wybe Dijkstra提出並解決了一個他稱之為哲學家進餐的同步問題。這個問題可以簡單地描述如下：五個哲學家圍坐在一張圓桌周圍，每個哲學家面前都有一盤通心粉。由於通心粉很滑，所以需要兩把叉子才能夾住。相鄰兩個盤子之間放有一把叉子如下圖所示。哲學家的生活中有兩種交替活動時段：即吃飯和思考。當一個哲學家覺得餓了時，他就試圖分兩次去取其左邊和右邊的叉子，每次拿一把，但不分次序。如果成功地得到了兩把叉子，就開始吃飯，吃完後放下叉子繼續思考。
把上面問題中的哲學家換成執行緒，把叉子換成競爭的臨界資源，上面的問題就是執行緒競爭資源的問題。如果沒有經過精心的設計，系統就會出現死鎖、活鎖、吞吐量下降等問題。

下面是用訊號量原語來解決哲學家進餐問題的程式碼，使用了Java 5併發工具包中的Semaphore類（程式碼不夠漂亮但是已經足以說明問題了）。

//import java.util.concurrent.ExecutorService;
//import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
 * 存放執行緒共享訊號量的上下問
 * @author 駱昊
 *
 */
class AppContext {
    public static final int NUM_OF_FORKS = 5;   // 叉子數量(資源)
    public static final int NUM_OF_PHILO = 5;   // 哲學家數量(執行緒)
    public static Semaphore[] forks;    // 叉子的訊號量
    public static Semaphore counter;    // 哲學家的訊號量
    static {
        forks = new Semaphore[NUM_OF_FORKS];
        for (int i = 0, len = forks.length; i < len; ++i) {
            forks[i] = new Semaphore(1);    // 每個叉子的訊號量為1
        }
        counter = new Semaphore(NUM_OF_PHILO - 1);  // 如果有N個哲學家，最多隻允許N-1人同時取叉子
    }
    /**
     * 取得叉子
     * @param index 第幾個哲學家
     * @param leftFirst 是否先取得左邊的叉子
     * @throws InterruptedException
     */
    public static void putOnFork(int index, boolean leftFirst) throws InterruptedException {
        if(leftFirst) {
            forks[index].acquire();
            forks[(index + 1) % NUM_OF_PHILO].acquire();
        }
        else {
            forks[(index + 1) % NUM_OF_PHILO].acquire();
            forks[index].acquire();
        }
    }
    /**
     * 放回叉子
     * @param index 第幾個哲學家
     * @param leftFirst 是否先放回左邊的叉子
     * @throws InterruptedException
     */
    public static void putDownFork(int index, boolean leftFirst) throws InterruptedException {
        if(leftFirst) {
            forks[index].release();
            forks[(index + 1) % NUM_OF_PHILO].release();
        }
        else {
            forks[(index + 1) % NUM_OF_PHILO].release();
            forks[index].release();
        }
    }
}
/**
 * 哲學家
 * @author 駱昊
 *
 */
class Philosopher implements Runnable {
    private int index;      // 編號
    private String name;    // 名字
    public Philosopher(int index, String name) {
        this.index = index;
        this.name = name;
    }
    @Override
    public void run() {
        while(true) {
            try {
                AppContext.counter.acquire();
                boolean leftFirst = index % 2 == 0;
                AppContext.putOnFork(index, leftFirst);
                System.out.println(name + "正在吃義大利麵（通心粉）...");   // 取到兩個叉子就可以進食
                AppContext.putDownFork(index, leftFirst);
                AppContext.counter.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Test04 {
    public static void main(String[] args) {
        String[] names = { "駱昊", "王大錘", "張三丰", "楊過", "李莫愁" };   // 5位哲學家的名字
//      ExecutorService es = Executors.newFixedThreadPool(AppContext.NUM_OF_PHILO); // 建立固定大小的執行緒池
//      for(int i = 0, len = names.length; i < len; ++i) {
//          es.execute(new Philosopher(i, names[i]));   // 啟動執行緒
//      }
//      es.shutdown();
        for(int i = 0, len = names.length; i < len; ++i) {
            new Thread(new Philosopher(i, names[i])).start();
        }
    }
}

現實中的併發問題基本上都是這三種模型或者是這三種模型的變體。

測試併發程式碼

對併發程式碼的測試也是非常棘手的事情，棘手到無需說明大家也很清楚的程度，所以這裡我們只是探討一下如何解決這個棘手的問題。我們建議大家編寫一些能夠發現問題的測試並經常性的在不同的配置和不同的負載下執行這些測試。不要忽略掉任何一次失敗的測試，執行緒程式碼中的缺陷可能在上萬次測試中僅僅出現一次。具體來說有這麼幾個注意事項：

不要將系統的失效歸結於偶發事件，就像拉不出屎的時候不能怪地球沒有引力。
先讓非併發程式碼工作起來，不要試圖同時找到併發和非併發程式碼中的缺陷。
編寫可以在不同配置環境下執行的執行緒程式碼。
編寫容易調整的執行緒程式碼，這樣可以調整執行緒使效能達到最優。
讓執行緒的數量多於CPU或CPU核心的數量，這樣CPU排程切換過程中潛在的問題才會暴露出來。
讓併發程式碼在不同的平臺上執行。
透過自動化或者硬編碼的方式向併發程式碼中加入一些輔助測試的程式碼。

Java 7的併發程式設計

Java 7中引入了TransferQueue，它比BlockingQueue多了一個叫transfer的方法，如果接收執行緒處於等待狀態，該操作可以馬上將任務交給它，否則就會阻塞直至取走該任務的執行緒出現。可以用TransferQueue代替BlockingQueue，因為它可以獲得更好的效能。
剛才忘記了一件事情，Java 5中還引入了Callable介面、Future介面和FutureTask介面，透過他們也可以構建併發應用程式，程式碼如下所示。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Test07 {
    private static final int POOL_SIZE = 10;
    static class CalcThread implements Callable<Double> {
        private List<Double> dataList = new ArrayList<>();
        public CalcThread() {
            for(int i = 0; i < 10000; ++i) {
                dataList.add(Math.random());
            }
        }
        @Override
        public Double call() throws Exception {
            double total = 0;
            for(Double d : dataList) {
                total += d;
            }
            return total / dataList.size();
        }
    }
    public static void main(String[] args) {
        List<Future<Double>> fList = new ArrayList<>();
        ExecutorService es = Executors.newFixedThreadPool(POOL_SIZE);
        for(int i = 0; i < POOL_SIZE; ++i) {
            fList.add(es.submit(new CalcThread()));
        }
        for(Future<Double> f : fList) {
            try {
                System.out.println(f.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        es.shutdown();
    }
}

Callable介面也是一個單方法介面，顯然這是一個回撥方法，類似於函數語言程式設計中的回撥函式，在Java 8 以前，Java中還不能使用Lambda表示式來簡化這種函數語言程式設計。和Runnable介面不同的是Callable介面的回撥方法call方法會返回一個物件，這個物件可以用將來時的方式線上程執行結束的時候獲得資訊。上面程式碼中的call方法就是將計算出的10000個0到1之間的隨機小數的平均值返回，我們透過一個Future介面的物件得到了這個返回值。目前最新的Java版本中，Callable介面和Runnable介面都被打上了@FunctionalInterface的註解，也就是說它可以用函數語言程式設計的方式（Lambda表示式）建立介面物件。

下面是Future介面的主要方法：

get()：獲取結果。如果結果還沒有準備好，get方法會阻塞直到取得結果；當然也可以透過引數設定阻塞超時時間。
cancel()：在運算結束前取消。
isDone()：可以用來判斷運算是否結束。

Java 7中還提供了分支/合併（fork/join）框架，它可以實現執行緒池中任務的自動排程，並且這種排程對使用者來說是透明的。為了達到這種效果，必須按照使用者指定的方式對任務進行分解，然後再將分解出的小型任務的執行結果合併成原來任務的執行結果。這顯然是運用了分治法（divide-and-conquer）的思想。下面的程式碼使用了分支/合併框架來計算1到10000的和，當然對於如此簡單的任務根本不需要分支/合併框架，因為分支和合並本身也會帶來一定的開銷，但是這裡我們只是探索一下在程式碼中如何使用分支/合併框架，讓我們的程式碼能夠充分利用現代多核CPU的強大運算能力。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
class Calculator extends RecursiveTask<Integer> {
    private static final long serialVersionUID = 7333472779649130114L;
    private static final int THRESHOLD = 10;
    private int start;
    private int end;
    public Calculator(int start, int end) {
        this.start = start;
        this.end = end;
    }
    @Override
    public Integer compute() {
        int sum = 0;
        if ((end - start) < THRESHOLD) {    // 當問題分解到可求解程度時直接計算結果
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            int middle = (start + end) >>> 1;
            // 將任務一分為二
            Calculator left = new Calculator(start, middle);
            Calculator right = new Calculator(middle + 1, end);
            left.fork();
            right.fork();
            // 注意：由於此處是遞迴式的任務分解，也就意味著接下來會二分為四，四分為八...
            sum = left.join() + right.join();   // 合併兩個子任務的結果
        }
        return sum;
    }
}
public class Test08 {
    public static void main(String[] args) throws Exception {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        Future<Integer> result = forkJoinPool.submit(new Calculator(1, 10000));
        System.out.println(result.get());
    }
}

伴隨著Java 7的到來，Java中預設的陣列排序演算法已經不再是經典的快速排序（雙樞軸快速排序）了，新的排序演算法叫TimSort，它是歸併排序和插入排序的混合體，TimSort可以透過分支合併框架充分利用現代處理器的多核特性，從而獲得更好的效能（更短的排序時間）。

版權宣告：本文為CSDN博主「駱昊」的原創文章
原文連結：關於Java併發程式設計的總結和思考_駱昊的技術專欄-CSDN部落格_java併發程式設計

Java併發程式設計基礎