摘要：一個線程池包含很多準備運行的空閑線程，每當執行完畢后，線程不會死亡而是回到線程池準備為下一個請求提供服務。另一個使用線程池的理由是減少并發線程數。創建大量線程會大大降低性能甚至拖垮虛擬機。

interface Future ，表示異步計算的結果，Future有個get方法而獲取結果只有在計算完成時獲取，否則會一直阻塞直到任務轉入完成狀態，然后會返回結果或者拋出異常。相對于繼承Thread來創建線程方式，使用Runnable可以讓你的實現類同時實現多個接口，而相對于Callable及Future，Runnable方法并不返回任務執行結果且不能拋出異常。

public interface Future {
    //取消計算，如果尚未開始，直接取消不再運算，如果正在進行：mayInterruptIfRunning等于true就會被中斷。注意一點：只要調用了cancle()，無論任務是否能夠執行，再調用get()都會出現cancledException,這是由于Future.state的狀態被置為CANCELLED = 4，所致的;
    boolean cancel(boolean mayInterruptIfRunning)
    //判斷計算是否取消。
    boolean isCancelled();
    //判斷計算是否完成，如果計算完成返回true，否則返回false
    boolean isDone();
    //獲得異步計算的結果，如果在調用get()的時候結果還沒有計算出來，調用線程將被阻塞。
    V get() throws InterruptedException, ExecutionException;
    //獲得異步計算的結果，如果在調用get()的時候結果還沒有計算出來，調用線程將被阻塞。如果調用超時將會拋出TimeoutException。
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

補充：

   - FutureTask：包裝器，可以將Callable轉換成為Future與Runnable,它同時實現了二者的接口。
   - Callable:可以為異步方法返回計算結果。
   

public class Exercise {

       private SimpleApplicationService simpleApplicationService = new SimpleApplicationService();

       @Test
       public void futureTest() throws InterruptedException, ExecutionException {
           long st = System.currentTimeMillis();
           //這里本是一callable接口實現，我用lambda方便一點
           FutureTask result = new FutureTask(() -> simpleApplicationService.query());
           //記住我們的任務都與需要開啟一個新的線程
           Thread t = new Thread(result);
           t.start();
           long end = System.currentTimeMillis();
           System.out.println("耗時：" + (end - st) + " 結果：" + result.get());
       }
   }

   public class SimpleApplicationService {
       public String query() throws InterruptedException {
           System.out.println("開始查詢");
           Thread.sleep(2000);
           return "query result";
       }
   }

每個異步方法都需要新開啟一個線程這樣很消耗資源。

每次都要new一個thread挺麻煩的。

構建一個新的線程是有代價的，因為設計到與操作系統的交互。如果程序中創建了大量的并且生命周期很短的線程，我們應該使用線程池。
一個線程池包含很多準備運行的空閑線程，每當run()執行完畢后，線程不會死亡而是回到線程池準備為下一個請求提供服務。

另一個使用線程池的理由是減少并發線程數。創建大量線程會大大降低性能甚至拖垮虛擬機。

Executors類有許多靜態方法可創建線程池。例如：

Executors.newCachedThreadPool():對于一個任務，有空閑線程可用則會立即執行，否則創建一個新的線程?？臻e線程存活60s。

Executors.newFixedThreadPool(n):構建具有固定大小的線程池，若任務多余空閑線程數，則將多余任務放置等待隊列中。

Executors.newSingleThreadExecutor()：只有一個空閑線程的線程池，任務執行一個接一個;

以上三個方法返回ExecutorService接口的ThreadPoolExecutor對象。

核心(簡介)：

ThreadPoolExecutor

    public class ThreadPoolExecutor extends AbstractExecutorService {

        public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                BlockingQueue workQueue);

        public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                BlockingQueue workQueue,ThreadFactory threadFactory);

        public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                BlockingQueue workQueue,RejectedExecutionHandler handler);

        //事實上，前面三個構造器都是調用的第四個構造器進行的初始化工作。
        public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);

    }
    

參數含義：

corePoolSize：核心池的大小，這個參數跟后面講述的線程池的實現原理有非常大的關系。在創建了線程池后，默認情況下，線程池中并沒有任何線程，而是等待有任務到來才創建線程去執行任務，除非調用了prestartAllCoreThreads()或者prestartCoreThread()方法。從這2個方法的名字就可以看出，是預創建線程的意思，即在沒有任務到來之前就創建corePoolSize個線程或者一個線程。默認情況下，在創建了線程池后，線程池中的線程數為0。當有任務來之后，就會創建一個線程去執行任務，當線程池中的線程數目達到corePoolSize后，就會把到達的任務放到緩存隊列當中；

maximumPoolSize：線程池最大線程數，這個參數也是一個非常重要的參數，它表示在線程池中最多能創建多少個線程；

keepAliveTime：表示線程沒有任務執行時最多保持多久時間會終止。默認情況下，只有當線程池中的線程數大于corePoolSize時，keepAliveTime才會起作用。直到線程池中的線程數不大于corePoolSize，即當線程池中的線程數大于corePoolSize時，如果一個線程空閑的時間達到keepAliveTime，則會終止，直到線程池中的線程數不超過corePoolSize。但是如果調用了allowCoreThreadTimeOut(boolean)方法，在線程池中的線程數不大于corePoolSize時，keepAliveTime參數也會起作用，直到線程池中的線程數為0；

unit：參數keepAliveTime的時間單位

workQueue：一個阻塞隊列，用來存儲等待執行的任務，這個參數的選擇也很重要，會對線程池的運行過程產生重大影響，一般來說，這里的阻塞隊列有以下幾種選擇:

   - ArrayBlockingQueue
   - LinkedBlockingQueue
   - SynchronousQueue;

threadFactory：線程工廠，主要用來創建線程；

handler：表示當拒絕處理任務時的策略，有以下四種取值：

          - ThreadPoolExecutor.AbortPolicy:丟棄任務并拋出RejectedExecutionException異常。
          - ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不拋出異常。
          - ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務，然后重新嘗試執行任務（重復此過程）
          - ThreadPoolExecutor.CallerRunsPolicy：由調用線程處理該任務
          

使用連接池應該做的事：

 1. 調用Executors的靜態方法創建線程池。
 2. 調用submit(),提交一個Callable對象或者Runnable對象。
 3. 保存好獲得的Future<>對象，其中是計算結果(如果提交的是Callable)。
 4. 沒有任何任務再提交的時候使用shutDown()。
 

 public class TaskExercise {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //future + callable
            ExecutorService executor = Executors.newCachedThreadPool();
            CallTask callTask = new CallTask();
            Future taskReturn = executor.submit(callTask);
            System.out.println(taskReturn.get());
            //futureTask
            FutureTask futureTask = new FutureTask(callTask);
            executor.submit(futureTask);
            System.out.println(futureTask.get());
            //runable
            Runnable runTask = new RunTask();
            String result = "xz";
            Future runTaskReturn = executor.submit(runTask,result);
            System.out.println(runTaskReturn.get());

            executor.shutdown();
        }
    }
    class CallTask implements Callable{
        @Override
        public String call() throws Exception {
            return "task return";
        }
    }
    class RunTask implements Runnable{
        @Override
        public void run() {
            System.out.println("run");
        }
    }
    

有時使用執行器更有意義的場景是控制一組相關任務。

1. shutdownNow():取消所有任務
2. invokeAny():提交所有對象到一個Callable對象集合，并返回某個已完成的任務結果。例如：如果你愿意接受任何一種解決方案的話。
3. 還有其他一些方法等我們真正用到時再學習好了~

spring中實現異步調用：spring為任務調度與異步方法執行提供了注解支持。通過在方法上設置@Async注解，可使得方法被異步調用。也就是說調用者會在調用時立即返回，而被調用方法的實際執行是交給Spring的TaskExecutor來完成。如果是有返回值的話記得：接口返回Future<>,實現返回AsyncResult<>。