資訊專欄INFORMATION COLUMN
摘要：能夠異步的執行任務，并且通常管理一個線程池。這樣我們就不用手動的去創建線程了，線程池中的所有線程都將被重用。在之后不能再提交任務到線程池。它不使用固定大小的線程池，默認情況下是主機的可用內核數。
原文地址： Java 8 Concurrency Tutorial: Threads and Executors
Java 5 初次引入了Concurrency API，并在隨后的發布版本中不斷優化和改進。這篇文章的大部分概念也適用于老的版本。我的代碼示例主要聚焦在Java 8上，并大量適用 lambda 表達式和一些新特性。如果你還不熟悉 lambda 表達式，建議先閱讀 Java 8 Tutorial。
Threads 和 Runnables所有現代操作系統都是通過進程和線程來支持并發的。進程通常是相互獨立運行的程序實例。例如，你啟動一個 Java 程序，操作系統會產生一個新的進程和其他程序并行運行。在這些進程中可以利用線程同時執行代碼。這樣我們就可以充分利用 CPU。
Java 從 JDK 1.0 開始就支持線程。在開始一個新線程之前，必須先指定運行的代碼，通常稱為 Task。下面是通過實現 Runnable 接口來啟動一個新線程的例子：
Runnable task = () -> {
String threadName = Thread.currentThread().getName();
System.out.println("Hello " + threadName);
};
task.run();
Thread thread = new Thread(task);
thread.start();
System.out.println("Done!");
由于 Runnable 是一個函數式接口，我們可以使用 lambda 表達式來打印線程的名字到控制臺。我們直接在主線程上執行Runnable，然后開始一個新線程。在控制臺你將看到這樣的結果：
Hello main Hello Thread-0 Done!
或者：
Hello main Done! Hello Thread-0
由于是并發執行，我們無法預測 Runnable 是在打印 Done 之前還是之后調用，順序不是不確定的，因此并發編程成為大型應用程序開發中一項復雜的任務。
線程也可以休眠一段時間，例如下面的例子：
Runnable runnable = () -> {
try {
String name = Thread.currentThread().getName();
System.out.println("Foo " + name);
TimeUnit.SECONDS.sleep(1);
System.out.println("Bar " + name);
}
catch (InterruptedException e) {
e.printStackTrace();
}
};
Thread thread = new Thread(runnable);
thread.start();
執行上面的代碼會在兩個打印語句之間停留1秒鐘。TimeUnit 是一個時間單位的枚舉，或者可以通過調用 Thread.sleep(1000) 實現。
使用 Thread 類可能非常繁瑣且容易出錯。由于這個原因，在2004年，Java 5版本引入了 Concurrency API。API 位于 java.util.concurrent 包下，包含了許多有用的有關并發編程的類。從那時起，每個新發布的 Java 版本都增加了并發 API，Java 8 也提供了新的類和方法來處理并發。
現在我們來深入了解一下Concurrency API中最重要的部分 - executor services。
ExecutorsConcurrency API 引入了 ExecutorService 的概念，作為處理線程的高級別方式用來替代 Threads。 Executors 能夠異步的執行任務，并且通常管理一個線程池。這樣我們就不用手動的去創建線程了，線程池中的所有線程都將被重用。從而可以在一個
executor service 的整個應用程序生命周期中運行盡可能多的并發任務。
下面是一個簡單的 executors 例子：
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(() -> {
String threadName = Thread.currentThread().getName();
System.out.println("Hello " + threadName);
});
// => Hello pool-1-thread-1
Executors 類提供了方便的工廠方法來創建不同類型的 executor services 。在這個例子中使用了只執行一個線程的 executor。
執行結果看起來和上面的示例類似，但是你會注意到一個重要區別：Java 進程永遠不會停止，執行者必須明確的停止它，否則它會不斷的接受新的任務。
ExecutorService 為此提供了兩種方法：shutdown() 等待當前任務執行完畢，而 shutdownNow() 則中斷所有正在執行的任務，并立即關閉執行程序。在 shudown 之后不能再提交任務到線程池。
下面是我關閉程序的首選方式：
try {
System.out.println("attempt to shutdown executor");
executor.shutdown();
executor.awaitTermination(5, TimeUnit.SECONDS);
}
catch (InterruptedException e) {
System.err.println("tasks interrupted");
}
finally {
if (!executor.isTerminated()) {
System.err.println("cancel non-finished tasks");
}
executor.shutdownNow();
System.out.println("shutdown finished");
}
執行者調用 shutdown 關閉 executor，在等待 5 秒鐘鐘后，不管任務有沒有執行完畢都調用 shutdownNow 中斷正在執行的任務而關閉。
Callables 和 Futures除了 Runnable 以外，executors 還支持 Callable 任務，和 Runnable 一樣是一個函數式接口，但它是有返回值的。
下面是一個使用 lambda 表達式定義的 Callable ，在睡眠 1 秒后返回一個整形值。
Callabletask = () -> { try { TimeUnit.SECONDS.sleep(1); return 123; } catch (InterruptedException e) { throw new IllegalStateException("task interrupted", e); } };
和 Runnable 一樣，Callable 也可以提交到 executor services，但是執行的結果是什么？由于 submit() 不等待任務執行完成，executor service 不能直接返回調用的結果。相對應的，它返回一個 Future 類型的結果，使用 Future 可以檢索實際執行結果。
ExecutorService executor = Executors.newFixedThreadPool(1); Futurefuture = executor.submit(task); System.out.println("future done? " + future.isDone()); Integer result = future.get(); System.out.println("future done? " + future.isDone()); System.out.print("result: " + result);
在將 Callable 提交給 executor 后，首先通過 isDone() 來檢查 future 是否執行完畢。我敢肯定，情況并非如此，因為上面的調用在返回整數之前睡眠了 1 秒鐘。
調用方法 get() 會阻塞當前線程，直到 callable 執行完成返回結果，現在 future 執行完成，并在控制臺輸出下面的結果：
future done? false future done? true result: 123
Future 與 executor service 緊密結合，如果關閉 executor service， 每個 Future 都會拋出異常。
executor.shutdownNow(); future.get();
這里創建 executor 的方式與前面的示例不同，這里使用 newFixedThreadPool(1) 來創建一個線程數量為 1 的線程池來支持 executor， 這相當于 newSingleThreadExecutor() ，稍后我們我們會通過傳遞一個大于 1 的值來增加線程池的大小。
Timeouts任何對 future.get()的調用都會阻塞并等待 Callable 被終止。 在最壞的情況下，一個可調用函數將永遠運行，從而使應用程序無法響應。可以簡單地通過超時來抵消這些情況：
ExecutorService executor = Executors.newFixedThreadPool(1); Futurefuture = executor.submit(() -> { try { TimeUnit.SECONDS.sleep(2); return 123; } catch (InterruptedException e) { throw new IllegalStateException("task interrupted", e); } }); future.get(1, TimeUnit.SECONDS);
執行上面的代碼會拋出 TimeoutException
Exception in thread "main" java.util.concurrent.TimeoutException
at java.util.concurrent.FutureTask.get(FutureTask.java:205)
指定了 1 秒鐘的最長等待時間，但是在返回結果之前，可調用事實上需要 2 秒鐘的時間。
InvokeAllExecutors 支持通過 invokeAll() 批量提交多個 Callable 。這個方法接受一個 Callable 類型集合的參數，并返回一個 Future 類型的 List。
