摘要：一個(gè)線程池包含很多準(zhǔn)備運(yùn)行的空閑線程，每當(dāng)執(zhí)行完畢后，線程不會死亡而是回到線程池準(zhǔn)備為下一個(gè)請求提供服務(wù)。另一個(gè)使用線程池的理由是減少并發(fā)線程數(shù)。創(chuàng)建大量線程會大大降低性能甚至拖垮虛擬機(jī)。

interface Future ，表示異步計(jì)算的結(jié)果，F(xiàn)uture有個(gè)get方法而獲取結(jié)果只有在計(jì)算完成時(shí)獲取，否則會一直阻塞直到任務(wù)轉(zhuǎn)入完成狀態(tài)，然后會返回結(jié)果或者拋出異常。相對于繼承Thread來創(chuàng)建線程方式，使用Runnable可以讓你的實(shí)現(xiàn)類同時(shí)實(shí)現(xiàn)多個(gè)接口，而相對于Callable及Future，Runnable方法并不返回任務(wù)執(zhí)行結(jié)果且不能拋出異常。

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

補(bǔ)充：

   - FutureTask：包裝器，可以將Callable轉(zhuǎn)換成為Future與Runnable,它同時(shí)實(shí)現(xiàn)了二者的接口。
   - Callable:可以為異步方法返回計(jì)算結(jié)果。
   

public class Exercise {

       private SimpleApplicationService simpleApplicationService = new SimpleApplicationService();

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

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

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

每次都要new一個(gè)thread挺麻煩的。

構(gòu)建一個(gè)新的線程是有代價(jià)的，因?yàn)樵O(shè)計(jì)到與操作系統(tǒng)的交互。如果程序中創(chuàng)建了大量的并且生命周期很短的線程，我們應(yīng)該使用線程池。
一個(gè)線程池包含很多準(zhǔn)備運(yùn)行的空閑線程，每當(dāng)run()執(zhí)行完畢后，線程不會死亡而是回到線程池準(zhǔn)備為下一個(gè)請求提供服務(wù)。

另一個(gè)使用線程池的理由是減少并發(fā)線程數(shù)。創(chuàng)建大量線程會大大降低性能甚至拖垮虛擬機(jī)。

Executors類有許多靜態(tài)方法可創(chuàng)建線程池。例如：

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

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

Executors.newSingleThreadExecutor()：只有一個(gè)空閑線程的線程池，任務(wù)執(zhí)行一個(gè)接一個(gè);

以上三個(gè)方法返回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);

        //事實(shí)上，前面三個(gè)構(gòu)造器都是調(diào)用的第四個(gè)構(gòu)造器進(jìn)行的初始化工作。
        public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);

    }
    

參數(shù)含義：

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

maximumPoolSize：線程池最大線程數(shù)，這個(gè)參數(shù)也是一個(gè)非常重要的參數(shù)，它表示在線程池中最多能創(chuàng)建多少個(gè)線程；

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

unit：參數(shù)keepAliveTime的時(shí)間單位

workQueue：一個(gè)阻塞隊(duì)列，用來存儲等待執(zhí)行的任務(wù)，這個(gè)參數(shù)的選擇也很重要，會對線程池的運(yùn)行過程產(chǎn)生重大影響，一般來說，這里的阻塞隊(duì)列有以下幾種選擇:

   - ArrayBlockingQueue
   - LinkedBlockingQueue
   - SynchronousQueue;

threadFactory：線程工廠，主要用來創(chuàng)建線程；

handler：表示當(dāng)拒絕處理任務(wù)時(shí)的策略，有以下四種取值：

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

使用連接池應(yīng)該做的事：

 1. 調(diào)用Executors的靜態(tài)方法創(chuàng)建線程池。
 2. 調(diào)用submit(),提交一個(gè)Callable對象或者Runnable對象。
 3. 保存好獲得的Future<>對象，其中是計(jì)算結(jié)果(如果提交的是Callable)。
 4. 沒有任何任務(wù)再提交的時(shí)候使用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");
        }
    }
    

有時(shí)使用執(zhí)行器更有意義的場景是控制一組相關(guān)任務(wù)。

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

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