先看幾個概念：
執行緒：程序中負責程式執行的執行單元。一個程序中至少有一個執行緒。

多執行緒：解決多工同時執行的需求，合理使用CPU資源。多執行緒的執行是根據CPU切換完成，如何切換由CPU決定，因此多執行緒執行具有不確定性。

執行緒池：基本思想還是一種物件池的思想，開闢一塊記憶體空間，裡面存放了眾多(未死亡)的執行緒，池中執行緒執行排程由池管理器來處理。當有執行緒任務時，從池中取一個，執行完成後執行緒物件歸池，這樣可以避免反覆建立執行緒物件所帶來的效能開銷，節省了系統的資源。

如果對執行緒概念不清晰的話，不妨先看看我是一個執行緒這篇文章，擬人化的故事闡述執行緒的工作原理。

● 執行緒

建立執行緒的兩種方式：

一、繼承Thread類，擴充套件執行緒。

class DemoThread extends Thread {

    @Override
    public void run() {
        super.run();
        // Perform time-consuming operation...
    }
}

DemoThread t = new DemoThread();
t.start();

• 繼承Thread類，覆蓋run()方法。
• 建立執行緒物件並用start()方法啟動執行緒。

面試題

• 1）執行緒和程序有什麼區別？

一個程序是一個獨立(self contained)的執行環境，它可以被看作一個程式或者一個應用。而執行緒是在程序中執行的一個任務。執行緒是程序的子集，一個程序可以有很多執行緒，每條執行緒並行執行不同的任務。不同的程序使用不同的記憶體空間，而所有的執行緒共享一片相同的記憶體空間。別把它和棧記憶體搞混，每個執行緒都擁有單獨的棧記憶體用來儲存本地資料。

• 2）如何在Java中實現執行緒？

建立執行緒有兩種方式：
一、繼承 Thread 類，擴充套件執行緒。
二、實現 Runnable 介面。

• 3）Thread 類中的 start() 和 run() 方法有什麼區別？

呼叫 start() 方法才會啟動新執行緒；如果直接呼叫 Thread 的 run() 方法，它的行為就會和普通的方法一樣；為了在新的執行緒中執行我們的程式碼，必須使用 Thread.start() 方法。

擴充套件

Android 系統介面 HandlerThread 繼承了 Thread，它是一個可以使用 Handler 的 Thread，一個具有訊息迴圈的執行緒。run()方法中通過 Looper.prepare() 來建立訊息佇列，通過 Looper.loop() 來開啟訊息迴圈。可以在 run() 方法中執行耗時的任務，而 HandlerThread 內部建立了訊息佇列外界需要通過 Handler 的方式來通知 HandlerThread 執行一個具體任務；HandlerThread 的 run() 方法是一個無限的迴圈，可以通過它的 quite() 或 quitSafely() 方法來終止執行緒的執行；

二、實現Runnable介面。

public class DemoActivity extends BaseActivity implements Runnable {

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		Thread t = new Thread(this);
		t.start();
	}

	@Override
	public void run() {

	}
}

面試題

• 1）用 Runnable 還是 Thread ？

我們都知道可以通過繼承 Thread 類或者呼叫 Runnable 介面來實現執行緒，問題是，建立執行緒哪種方式更好呢？什麼情況下使用它？這個問題很容易回答，如果你知道Java不支援類的多重繼承，但允許你呼叫多個介面。所以如果你要繼承其他類，當然是呼叫Runnable介面更好了。

• 2）Runnable 和 Callable 有什麼不同？

Runnable 和 Callable 都代表那些要在不同的執行緒中執行的任務。Runnable 從 JDK1.0 開始就有了，Callable 是在 JDK1.5 增加的。它們的主要區別是 Callable 的 call() 方法可以返回值和丟擲異常，而 Runnable 的 run() 方法沒有這些功能。Callable 可以返回裝載有計算結果的 Future 物件。

⚠注意：這面第二個面試題主要是為了引出下面的擴充套件，原諒我這樣為難人的出場。

擴充套件

先看一下 Runnable 和 Callable 的原始碼

public interface Runnable {
	public void run();
}

public interface Callable<V> {
	V call() throws Exception;
}

可以得出：

1）Callable 介面下的方法是 call()，Runnable 介面的方法是 run()。
2）Callable 的任務執行後可返回值，而 Runnable 的任務是不能返回值的。
3）call() 方法可以丟擲異常，run()方法不可以的。
4）執行 Callable 任務可以拿到一個 Future 物件，表示非同步計算的結果。它提供了檢查計算是否完成的方法，以等待計算的完成，並檢索計算的結果。通過 Future 物件可以瞭解任務執行情況，可取消任務的執行，還可獲取執行結果。

但是，但是，凡事都有但是嘛…

單獨使用 Callable，無法在新執行緒中(new Thread(Runnable r))使用，Thread 類只支援 Runnable。不過 Callable 可以使用 ExecutorService (又丟擲一個概念，這個概念將在下面的執行緒池中說明)。

上面又提到了 Future，看一下 Future 介面：

public interface Future<V> {

	boolean cancel(boolean mayInterruptIfRunning);

	boolean isCancelled();

	boolean isDone();

	V get() throws InterruptedException, ExecutionException;

	V get(long timeout, TimeUnit unit)
    	throws InterruptedException, ExecutionException, TimeoutException;
}

Future 定義了5個方法：

1）boolean cancel(boolean mayInterruptIfRunning)：試圖取消對此任務的執行。如果任務已完成、或已取消，或者由於某些其他原因而無法取消，則此嘗試將失敗。當呼叫 cancel() 時，如果呼叫成功，而此任務尚未啟動，則此任務將永不執行。如果任務已經啟動，則 mayInterruptIfRunning 引數確定是否應該以試圖停止任務的方式來中斷執行此任務的執行緒。此方法返回後，對 isDone() 的後續呼叫將始終返回 true。如果此方法返回 true，則對 isCancelled() 的後續呼叫將始終返回 true。
2）boolean isCancelled()：如果在任務正常完成前將其取消，則返回 true。
3）boolean isDone()：如果任務已完成，則返回 true。 可能由於正常終止、異常或取消而完成，在所有這些情況中，此方法都將返回 true。
4）V get()throws InterruptedException,ExecutionException：如有必要，等待計算完成，然後獲取其結果。
5）V get(long timeout,TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException： 如有必要，最多等待為使計算完成所給定的時間之後，獲取其結果（如果結果可用）。

看來 Future 介面也不能用線上程中，那怎麼用，誰實現了 Future 介面呢？答：FutureTask。

public class FutureTask<V> implements RunnableFuture<V> {
	...
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
	void run();
}

FutureTask 實現了 Runnable 和 Future，所以兼顧兩者優點，既可以在 Thread 中使用，又可以在 ExecutorService 中使用。

看完上面囉哩囉嗦的介紹後，下面我們具體看一下具體使用的示例：

Callable<String> callable = new Callable<String>() {
    @Override
    public String call() throws Exception {
        return "個人部落格：sunfusheng.com";
    }
};

FutureTask<String> task = new FutureTask<String>(callable);

Thread t = new Thread(task);
t.start(); // 啟動執行緒
task.cancel(true); // 取消執行緒

使用 FutureTask 的好處是 FutureTask 是為了彌補 Thread 的不足而設計的，它可以讓程式設計師準確地知道執行緒什麼時候執行完成並獲得到執行緒執行完成後返回的結果。FutureTask 是一種可以取消的非同步的計算任務，它的計算是通過 Callable 實現的，它等價於可以攜帶結果的 Runnable，並且有三個狀態：等待、執行和完成。完成包括所有計算以任意的方式結束，包括正常結束、取消和異常。

● 多執行緒

多執行緒的概念很好理解就是多條執行緒同時存在，但要用好多執行緒確不容易，涉及到多執行緒間通訊，多執行緒共用一個資源等諸多問題。

使用多執行緒的優缺點：
優點：
1）適當的提高程式的執行效率（多個執行緒同時執行）。
2）適當的提高了資源利用率（CPU、記憶體等）。
缺點：
1）佔用一定的記憶體空間。
2）執行緒越多CPU的排程開銷越大。
3）程式的複雜度會上升。

對於多執行緒的示例程式碼感興趣的可以自己寫Demo啦，去執行體會，下面我主要列出一些多執行緒的技術點。

synchronized

同步塊大家都比較熟悉，通過 synchronized 關鍵字來實現；所有加上 synchronized 的方法和塊語句，在多執行緒訪問的時候，同一時刻只能有一個執行緒能夠訪問。

wait()、notify()、notifyAll()

這三個方法是 java.lang.Object 的 final native 方法，任何繼承 java.lang.Object 的類都有這三個方法。它們是Java語言提供的實現執行緒間阻塞和控制程序內排程的底層機制，平時我們會很少用到的。

wait()：
導致執行緒進入等待狀態，直到它被其他執行緒通過notify()或者notifyAll喚醒，該方法只能在同步方法中呼叫。

notify()：
隨機選擇一個在該物件上呼叫wait方法的執行緒，解除其阻塞狀態，該方法只能在同步方法或同步塊內部呼叫。

notifyAll()：
解除所有那些在該物件上呼叫wait方法的執行緒的阻塞狀態，同樣該方法只能在同步方法或同步塊內部呼叫。

呼叫這三個方法中任意一個，當前執行緒必須是鎖的持有者，如果不是會丟擲一個 IllegalMonitorStateException 異常。

wait() 與 Thread.sleep(long time) 的區別

sleep()：在指定的毫秒數內讓當前正在執行的執行緒休眠（暫停執行），該執行緒不丟失任何監視器的所屬權，sleep() 是 Thread 類專屬的靜態方法，針對一個特定的執行緒。
wait() 方法使實體所處執行緒暫停執行，從而使物件進入等待狀態，直到被 notify() 方法通知或者 wait() 的等待的時間到。sleep() 方法使持有的執行緒暫停執行，從而使執行緒進入休眠狀態，直到用 interrupt 方法來打斷他的休眠或者 sleep 的休眠的時間到。
wait() 方法進入等待狀態時會釋放同步鎖，而 sleep() 方法不會釋放同步鎖。所以，當一個執行緒無限 sleep 時又沒有任何人去 interrupt 它的時候，程式就產生大麻煩了，notify() 是用來通知執行緒，但在 notify() 之前執行緒是需要獲得 lock 的。另個意思就是必須寫在 synchronized(lockobj) {…} 之中。wait() 也是這個樣子，一個執行緒需要釋放某個 lock，也是在其獲得 lock 情況下才能夠釋放，所以 wait() 也需要放在 synchronized(lockobj) {…} 之中。

volatile 關鍵字

volatile 是一個特殊的修飾符，只有成員變數才能使用它。在Java併發程式缺少同步類的情況下，多執行緒對成員變數的操作對其它執行緒是透明的。volatile 變數可以保證下一個讀取操作會在前一個寫操作之後發生。執行緒都會直接從記憶體中讀取該變數並且不快取它。這就確保了執行緒讀取到的變數是同記憶體中是一致的。

ThreadLocal 變數

ThreadLocal 是Java裡一種特殊的變數。每個執行緒都有一個 ThreadLocal 就是每個執行緒都擁有了自己獨立的一個變數，競爭條件被徹底消除了。如果為每個執行緒提供一個自己獨有的變數拷貝，將大大提高效率。首先，通過複用減少了代價高昂的物件的建立個數。其次，你在沒有使用高代價的同步或者不變性的情況下獲得了執行緒安全。

join() 方法

join() 方法定義在 Thread 類中，所以呼叫者必須是一個執行緒，join() 方法主要是讓呼叫該方法的 Thread 完成 run() 方法裡面的東西后，再執行 join() 方法後面的程式碼，看下下面的”意思”程式碼：

Thread t1 = new Thread(計數執行緒一);  
Thread t2 = new Thread(計數執行緒二);  
t1.start();  
t1.join(); // 等待計數執行緒一執行完成，再執行計數執行緒二
t2.start();  

啟動 t1 後，呼叫了 join() 方法，直到 t1 的計數任務結束，才輪到 t2 啟動，然後 t2 才開始計數任務，兩個執行緒是按著嚴格的順序來執行的。如果 t2 的執行需要依賴於 t1 中的完整資料的時候，這種方法就可以很好的確保兩個執行緒的同步性。

Thread.yield() 方法

Thread.sleep(long time)：執行緒暫時終止執行（睡眠）一定的時間。 
Thread.yield()：執行緒放棄執行，將CPU的控制權讓出。 

這兩個方法都會將當前執行執行緒的CPU控制權讓出來，但 sleep() 方法在指定的睡眠時間內一定不會再得到執行機會，直到它的睡眠時間完成；而 yield() 方法讓出控制權後，還有可能馬上被系統的排程機制選中來執行，比如，執行yield()方法的執行緒優先順序高於其他的執行緒，那麼這個執行緒即使執行了 yield() 方法也可能不能起到讓出CPU控制權的效果，因為它讓出控制權後，進入排隊佇列，排程機制將從等待執行的執行緒佇列中選出一個等級最高的執行緒來執行，那麼它又（很可能）被選中來執行。

擴充套件

執行緒排程策略

(1) 搶佔式排程策略

Java執行時系統的執行緒排程演算法是搶佔式的。Java執行時系統支援一種簡單的固定優先順序的排程演算法。如果一個優先順序比其他任何處於可執行狀態的執行緒都高的執行緒進入就緒狀態，那麼執行時系統就會選擇該執行緒執行。新的優先順序較高的執行緒搶佔了其他執行緒。但是Java執行時系統並不搶佔同優先順序的執行緒。換句話說，Java執行時系統不是分時的。然而，基於Java Thread類的實現系統可能是支援分時的，因此編寫程式碼時不要依賴分時。當系統中的處於就緒狀態的執行緒都具有相同優先順序時，執行緒排程程式採用一種簡單的、非搶佔式的輪轉的排程順序。

(2) 時間片輪轉排程策略

有些系統的執行緒排程採用時間片輪轉排程策略。這種排程策略是從所有處於就緒狀態的執行緒中選擇優先順序最高的執行緒分配一定的CPU時間執行。該時間過後再選擇其他執行緒執行。只有當執行緒執行結束、放棄(yield)CPU或由於某種原因進入阻塞狀態，低優先順序的執行緒才有機會執行。如果有兩個優先順序相同的執行緒都在等待CPU，則排程程式以輪轉的方式選擇執行的執行緒。

以上把這些技術點總結出來，後面我會把多執行緒這塊的示例程式碼更新到 《個人學習專案DroidStudy》，感謝您的關注。

● 執行緒池

建立多個執行緒不光麻煩而且相對影響系統性能，接下來讓我看看使用執行緒池來操作多執行緒。我把自己的《個人學習專案DroidStudy》 中執行緒池轉成一個 gif 效果圖，大家可以實際把玩下去感受執行緒池的原理，有興趣的同學也可以先 star 下，我會在接下來的幾個月把這個學習的Demo工程完善好。

執行緒池的優點

1）避免執行緒的建立和銷燬帶來的效能開銷。
2）避免大量的執行緒間因互相搶佔系統資源導致的阻塞現象。
3｝能夠對執行緒進行簡單的管理並提供定時執行、間隔執行等功能。

再擼一擼概念

Java裡面執行緒池的頂級介面是 Executor，不過真正的執行緒池介面是 ExecutorService， ExecutorService 的預設實現是 ThreadPoolExecutor；普通類 Executors 裡面呼叫的就是 ThreadPoolExecutor。

照例看一下各個介面的原始碼：

public interface Executor {
	void execute(Runnable command);
}

public interface ExecutorService extends Executor {
	void shutdown();
	List<Runnable> shutdownNow();
	
	boolean isShutdown();
	boolean isTerminated();
	
	<T> Future<T> submit(Callable<T> task);
	<T> Future<T> submit(Runnable task, T result);
	Future<?> submit(Runnable task);
	...
}

public class Executors {
	public static ExecutorService newCachedThreadPool() {
    		return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, 
    						new SynchronousQueue<Runnable>());
	}
	...
}

下面我建立的一個執行緒池：

ExecutorService pool = Executors.newCachedThreadPool();

Executors 提供四種執行緒池：

• 1）newCachedThreadPool 是一個可根據需要建立新執行緒的執行緒池，但是在以前構造的執行緒可用時將重用它們。對於執行很多短期非同步任務的程式而言，這些執行緒池通常可提高程式效能。呼叫 execute() 將重用以前構造的執行緒（如果執行緒可用）。如果現有執行緒沒有可用的，則建立一個新執行緒並新增到池中。終止並從快取中移除那些已有 60 秒鐘未被使用的執行緒。因此，長時間保持空閒的執行緒池不會使用任何資源。注意，可以使用 ThreadPoolExecutor 構造方法建立具有類似屬性但細節不同（例如超時引數）的執行緒池。

• 2）newSingleThreadExecutor 建立是一個單執行緒池，也就是該執行緒池只有一個執行緒在工作，所有的任務是序列執行的，如果這個唯一的執行緒因為異常結束，那麼會有一個新的執行緒來替代它，此執行緒池保證所有任務的執行順序按照任務的提交順序執行。

• 3）newFixedThreadPool 建立固定大小的執行緒池，每次提交一個任務就建立一個執行緒，直到執行緒達到執行緒池的最大大小，執行緒池的大小一旦達到最大值就會保持不變，如果某個執行緒因為執行異常而結束，那麼執行緒池會補充一個新執行緒。

• 4）newScheduledThreadPool 建立一個大小無限的執行緒池，此執行緒池支援定時以及週期性執行任務的需求。

通過 ThreadPoolExecutor 的建構函式，擼一擼執行緒池相關引數的概念：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, 
    	threadFactory, defaultHandler);
}

• 1）corePoolSize：執行緒池的核心執行緒數，一般情況下不管有沒有任務都會一直線上程池中一直存活，只有在 ThreadPoolExecutor 中的方法 allowCoreThreadTimeOut(boolean value) 設定為 true 時，閒置的核心執行緒會存在超時機制，如果在指定時間沒有新任務來時，核心執行緒也會被終止，而這個時間間隔由第3個屬性 keepAliveTime 指定。

• 2）maximumPoolSize：執行緒池所能容納的最大執行緒數，當活動的執行緒數達到這個值後，後續的新任務將會被阻塞。

• 3）keepAliveTime：控制執行緒閒置時的超時時長，超過則終止該執行緒。一般情況下用於非核心執行緒，只有在 ThreadPoolExecutor 中的方法 allowCoreThreadTimeOut(boolean value) 設定為 true時，也作用於核心執行緒。

• 4）unit：用於指定 keepAliveTime 引數的時間單位，TimeUnit 是個 enum 列舉型別，常用的有：TimeUnit.HOURS(小時)、TimeUnit.MINUTES(分鐘)、TimeUnit.SECONDS(秒) 和 TimeUnit.MILLISECONDS(毫秒)等。

• 5）workQueue：執行緒池的任務佇列，通過執行緒池的 execute(Runnable command) 方法會將任務 Runnable 儲存在佇列中。

• 6）threadFactory：執行緒工廠，它是一個介面，用來為執行緒池建立新執行緒的。

執行緒池的關閉

ThreadPoolExecutor 提供了兩個方法，用於執行緒池的關閉，分別是 shutdown() 和 shutdownNow()。

shutdown()：不會立即的終止執行緒池，而是要等所有任務快取佇列中的任務都執行完後才終止，但再也不會接受新的任務。
shutdownNow()：立即終止執行緒池，並嘗試打斷正在執行的任務，並且清空任務快取佇列，返回尚未執行的任務。

面試題

1）什麼是 Executor 框架？

Executor框架在Java 5中被引入，Executor 框架是一個根據一組執行策略呼叫、排程、執行和控制的非同步任務的框架。

無限制的建立執行緒會引起應用程式記憶體溢位，所以建立一個執行緒池是個更好的的解決方案，因為可以限制執行緒的數量並且可以回收再利用這些執行緒。利用 Executor 框架可以非常方便的建立一個執行緒池。

2）Executors 類是什麼？

Executors為Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 類提供了一些工具方法。Executors 可以用於方便的建立執行緒池