1.簡介
使用線程池可以避免線程的頻繁創建以及銷毀。
JAVA中提供的用於實現線程池的API：
Executor、ExecutorService、AbstractExecutorService、ThreadPoolExecutor、ForkJoinPool都位於java.util.concurrent包下。
*ThreadPoolExecutor、ForkJoinPool為線程池的實現類。
2.Executor接口
public interface Executor { /** * 向線程池提交一個任務,交由線程池去執行 */
void execute(Runnable command); }
*該接口聲明了execute(Runnable command)方法，負責向線程池中提交一個任務。
3.ExecutorService接口
public interface ExecutorService extends Executor { /** * 關閉線程池(等待隊列中的任務被執行完畢) */
void shutdown(); /** * 立刻關閉線程池(不執行隊列中的任務，並嘗試中斷當前執行的任務) */ List<Runnable> shutdownNow(); /** * 判斷線程池是否處於shutdown狀態. */
boolean isShutdown(); /** * 判斷線程池是否處於terminated狀態. */
boolean isTerminated(); /** * 若在指定時間內線程池處於terminated狀態則立即返回true,否則超過時間后仍未為terminated狀態則返回false. */
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException; /** * 向線程池提交一個任務並返回包含指定類型的Future(根據Callable的泛型) */
<T> Future<T> submit(Callable<T> task); /** * 向線程池提交一個任務並指定任務執行結果的類型,返回包含指定類型的Future. */
<T> Future<T> submit(Runnable task, T result); /** * 向線程池提交一個任務並返回未知類型的Future. */ Future<?> submit(Runnable task); /** * 向線程池提交多個任務並返回指定類型的Future列表. */
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException; /** * 向線程池提交多個任務並返回指定類型的Future列表,如果在指定時間內沒有執行完畢則直接返回. */
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException; /** * 向線程池提交多個任務,當任意一個任務執行完畢后返回指定類型的Future. */
<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException; /** * 向線程池提交多個任務,在指定時間內,當任意一個任務執行完畢后返回指定類型的Future,若超時則拋出異常. */
<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
public interface Future<V> { /** * 中斷任務的執行 */
boolean cancel(boolean mayInterruptIfRunning); /** * 判斷任務是否中斷成功 */
boolean isCancelled(); /** * 判斷任務是否執行完成 */
boolean isDone(); /** * 獲取任務的執行結果直到任務執行完畢(阻塞線程) */ V get() throws InterruptedException, ExecutionException; /** * 獲取任務的執行結果,若在指定時間內任務仍然沒有執行完畢則拋出TimeoutException */ V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
*execute()方法不能獲取任務的執行結果，而submit()方法能夠根據返回的Future實例獲取任務的執行結果。
4.ThreadPoolExecutor
ThreadPoolExecutor聲明的核心屬性
corePoolSize：線程池中核心線程的數量。
maximumPoolSize：線程池中最大線程數。
keepAliveTime：線程的空閑時間。
unit：線程空閑時間的單位。
workQueue：任務隊列。
threadFactory：線程工廠，用於創建線程。
handler：當隊列已滿且當前線程數已達到所允許的最大值時的處理策略。
*線程池中的線程包括核心線程以及普通線程，核心線程一旦創建后直到線程池被關閉前都就不會被銷毀，而普通線程會因為到達空閑時間而被銷毀。
構造方法：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
BlockingQueue的類型
BlockingQueue提供了ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等實現類。
1.ArrayBlockingQueue：使用順序表的結構進行存儲，在使用時需要指定其長度，支持公平鎖/非公平鎖進行操作。
2.LinkedBlockingQueue：使用鏈表的結構進行存儲，在使用時不需要指定其長度，隊列的最大長度為Integer.MAX_VALUE。
3.SynchronousQueue：一個不存儲元素的隊列，每一個put操作必須等待take操作，否則不能添加元素，支持公平鎖和非公平鎖。
*這些實現類在進行入隊和出隊操作時都會進行加鎖，以保證在多線程並發訪問時數據的安全性。
隊列已滿且線程數已達到所允許的最大值時的處理策略
RejectedExecutionHandler提供了AbortPolicy、DiscardPolicy、DiscardOlderstPolicy、CallerRunsPolicy四個策略，這四個策略都是ThreadPoolExecutor的靜態內部類。
1.AbortPolicy：放棄任務並拋出RejectedExecutionException異常。
2.DiscardPolicy：放棄任務但不拋出異常。
3.DiscardOlderstPolicy： 放棄隊頭中的任務，然后重新嘗試執行新任務。
4.CallerRunsPolicy： 由調用線程來處理該任務。
線程池的狀態
private static final int RUNNING = -1； private static final int SHUTDOWN = 0； private static final int STOP = 1； private static final int TIDYING = 2； private static final int TERMINATED = 3；
1.RUNING：線程池處於運行狀態，此時可以接受新的任務請求，並且執行隊列中的任務。
2.SHUTDOWN：線程池處於關閉狀態，此時不接受新的任務請求，但會繼續執行隊列中的任務。
3.STOP：線程池處於禁用狀態，此時不接受新的任務請求，並且不會執行隊列中的任務。
4.TIDYING：線程池處於整理狀態，此時沒有正在執行的任務。
5.TERMINATED ：線程池處於終止狀態。
線程池狀態的變化過程
1.當線程池創建后處於RUNNING狀態。
2.1 若此時調用了shutdown()方法，那么線程池將處於SHUTDOWN狀態，不接受新的任務請求，但會繼續執行隊列中的任務，當隊列中的任務為空且沒有正在執行的任務時，線程池的狀態為TIDYING。
2.2 若此時調用了shutdownNow()方法，那么線程池將處於STOP狀態，不接受新的任務請求並且不執行隊列中的任務，此時線程池的狀態為TIDYING。
3.當線程池的狀態為TIDYING時，當terminated()方法處理完畢后，線程池的狀態為TRRMINATED。
任務的執行流程
1.當調用了execute()或者submit()方法向線程池提交一個任務后，首先判斷當前線程池中的線程個數是否大於核心線程數。
2.如果當前線程池的線程個數小於核心線程數，則創建一個核心線程來處理任務。
3.如果當前線程池的線程個數大於核心線程數，則將任務放入到隊列中，如果放入隊列成功，那么該任務將等待被空閑的線程處理，如果放入隊列失敗(隊滿)，則判斷當前線程池中的線程個數是否達到所允許的最大值，若未達到則創建一個普通線程去處理任務，否則根據預定義的處理策略去進行處理。
5.Executors工具類
JAVA中提供了Executors工具類，用於直接創建Executor。
CacheThreadPool
public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>()); }
CacheThreadPool創建的都是普通線程(其核心線程數為0)、線程池的最大線程數為Integer.MAX_VALUE、線程的空閑時間為60秒，此方式適合大量耗時短的任務、不適合大量耗時長的任務。
*由於創建的都是普通線程，且空閑時間為60秒，則仍有可能會頻繁的創建線程。
FixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()); }
FixedThreadPool創建的都是核心線程，其線程個數由入參決定，線程不會因為空閑時間而被銷毀，適合預知任務數量的業務。
SingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,new LinkedBlockingQueue<Runnable>())); }
SingleThreadExecutor使用一個核心線程來處理任務。
ScheduledThreadPool
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize); }
*ScheduledThreadPool支持定時執行任務以及固定間隔執行任務。
SingleThreadScheduledExecutor
public static ScheduledExecutorService newSingleThreadScheduledExecutor() { return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1)); }
*SingleThreadScheduledExecutor支持一個線程的定時執行任務以及固定間隔執行任務。
public interface ScheduledExecutorService extends ExecutorService { /** * 在指定的延遲時間到達后執行任務一次 */
public ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit); /** * 在指定的延遲時間到達后執行任務一次 */
public <V> ScheduledFuture<V> schedule(Callable<V> callable,long delay, TimeUnit unit); /** * 在指定的初始化延遲時間到達后執行任務一次,往后每隔period時間執行任務一次. */
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit); /** * 在指定的初始化延遲時間到達后執行任務一次,往后每次任務執行完畢后相隔delay時間執行任務一次. */
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit); }
WorkStealingPool
public static ExecutorService newWorkStealingPool(int parallelism) { return new ForkJoinPool(parallelism,ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true); }
WorkStealingPool創建一個並行級別的線程池，同一時刻最多只能有指定個數個線程正在執行任務，創建時直接指定同一時刻最多能允許的並行執行的線程個數即可，如果不傳則使用CPU的核數。
newWorkStealingPool方法內部返回一個ForkJoinPool實例，ForkJoinPool是JAVA7新提供的線程池，同樣繼承AbstactExecutorService。