Java ExecutorService四種線程池使用

1.引言 合理利用線程池可以帶來三個好處。第一：下降資源消耗。經過重複利用已建立的線程下降線程建立和銷燬形成的消耗。第二：提升響應速度。當任務到達時，任務能夠不須要的等到線程建立就能當即執行。第三：提升線程的可管理性。線程是稀缺資源，若是無限制的建立，不只會消耗系統資源，還會下降系統的穩定性，使用線程池能夠進行統一的分配，調優和監控。可是要作到合理的利用線程池，必須對其原理了如指掌。

2.線程池使用 Executors提供的四種線程 1.newCachedThreadPool建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。 2.newFixedThreadPool 建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。 3.newScheduledThreadPool 建立一個定長線程池，支持定時及週期性任務執行。 4.newSingleThreadExecutor 建立一個單線程化的線程池，它只會用惟一的工做線程來執行任務，保證全部任務按照指定順序(FIFO, LIFO, 優先級)執行。

1.newCachedThreadPool建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。示例以下

ExecutorService executorService = Executors.newCachedThreadPool();
for(int i=0;i<5;i++){
    final int index = i;
    try {
        Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    executorService.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() +  "," +index);
        }
    });
}
//控制檯信息
pool-1-thread-1,0
pool-1-thread-1,1
pool-1-thread-1,2
pool-1-thread-1,3
pool-1-thread-1,4

2.newFixedThreadPool建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。示例以下

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
for(int i=0;i<5;i++) {
    final int index = i;
       fixedThreadPool.execute(new Runnable() {
        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + ", " + index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
}
//控制檯信息
pool-1-thread-1,0
pool-1-thread-2,1
pool-1-thread-3,2
pool-1-thread-4,3
pool-1-thread-1,4

3.newScheduledThreadPool 建立一個定長線程池，支持週期和定時任務示例以下

ScheduledExecutorService scheduledThreadPool =  Executors.newScheduledThreadPool(5);
System.out.println("before:" + System.currentTimeMillis()/1000);
scheduledThreadPool.schedule(new Runnable() {
    @Override
    public void run() {
        System.out.println("延遲3秒執行的哦 :" + System.currentTimeMillis()/1000);
    }
}, 3, TimeUnit.SECONDS);
System.out.println("after :" +System.currentTimeMillis()/1000);
//控制檯信息
before:1518012703
after :1518012703
延遲3秒執行的哦 :1518012706
System.out.println("before:" + System.currentTimeMillis()/1000);
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println("延遲1秒以後，3秒執行一次:" +System.currentTimeMillis()/1000);
    }
}, 1, 3, TimeUnit.SECONDS);
System.out.println("after :" +System.currentTimeMillis()/1000);
控制檯消息
before:1518013024
after :1518013024
延遲1秒以後，3秒執行一次:1518013025
延遲1秒以後，3秒執行一次:1518013028
延遲1秒以後，3秒執行一次:1518013031

4.newSingleThreadExecutor建立一個單線程化的線程池，只會用工做線程來執行任務，保證順序，示例以下

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i=0;i<10;i++) {
    final int index = i;
    singleThreadExecutor.execute(new Runnable() {
        @Override
        public void run() {
            try {
                  System.out.println(Thread.currentThread().getName() + "," + index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
}
//控制檯信息
pool-1-thread-1,0
pool-1-thread-1,1
pool-1-thread-1,2
pool-1-thread-1,3
pool-1-thread-1,4

向線程池提交任務 ThreadPoolExecutor類中execute()和submit()區別 execute()方法其實是Executor中聲明的方法，在ThreadPoolExecutor進行了具體的實現，這個方法是ThreadPoolExecutor的核心方法，經過這個方法能夠向線程池提交一個任務，交由線程池去執行。

submit()方法是在ExecutorService中聲明的方法，在AbstractExecutorService就已經有了具體的實現，在ThreadPoolExecutor中並無對其進行重寫，這個方法也是用來向線程池提交任務的，可是它和execute()方法不一樣，它可以返回任務執行的結果，經過源碼查看submit()方法的實現，會發現它實際上仍是調用的execute()方法，只不過它利用了Future來獲取任務執行結果。

/**
 * @throws RejectedExecutionException {@inheritDoc}
 * @throws NullPointerException       {@inheritDoc}
 */
public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

線程池的關閉 咱們能夠經過調用線程池的shutdown或shutdownNow方法來關閉線程池，可是它們的實現原理不一樣，shutdown的原理是隻是將線程池的狀態設置成SHUTDOWN狀態，而後中斷全部沒有正在執行任務的線程。shutdownNow的原理是遍歷線程池中的工做線程，而後逐個調用線程的interrupt方法來中斷線程，因此沒法響應中斷的任務可能永遠沒法終止。shutdownNow會首先將線程池的狀態設置成STOP，而後嘗試中止全部的正在執行或暫停任務的線程，並返回等待執行任務的列表。

只要調用了這兩個關閉方法的其中一個，isShutdown方法就會返回true。當全部的任務都已關閉後,才表示線程池關閉成功，這時調用isTerminaed方法會返回true。至於咱們應該調用哪種方法來關閉線程池，應該由提交到線程池的任務特性決定，一般調用shutdown來關閉線程池，若是任務不必定要執行完，則能夠調用shutdownNow。

3.    線程池的分析 流程分析：線程池的主要工做流程以下圖：

從上圖咱們能夠看出，當提交一個新任務到線程池時，線程池的處理流程以下：

1. 首先線程池判斷基本線程池是否已滿？沒滿，建立一個工做線程來執行任務。滿了，則進入下個流程。
2. 其次線程池判斷工做隊列是否已滿？沒滿，則將新提交的任務存儲在工做隊列裏。滿了，則進入下個流程。
3. 最後線程池判斷整個線程池是否已滿？沒滿，則建立一個新的工做線程來執行任務，滿了，則交給飽和策略來處理這個任務。

**源碼分析。**上面的流程分析讓咱們很直觀的瞭解的線程池的工做原理，讓咱們再經過源代碼來看看是如何實現的。線程池執行任務的方法以下：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    else if (!addWorker(command, false))
        reject(command);
}

工做線程。線程池建立線程時，會將線程封裝成工做線程Worker，Worker在執行完任務後，還會無限循環獲取工做隊列裏的任務來執行。 ▼長按如下二維碼便可關注▼ 2018年請與我一塊兒打怪升級