JAVA線程池的原理及使用

三線程池的實現和執行原理

一使用線程池的原因

直接創建線程，雖然非常簡便，但是如果併發或訪問量比較大的情況下，每個線程執行一個很短的任務就結束，頻繁創建線程效率低下，消耗時間。
一般在代碼裏沒有直接new線程的操作，需要建立線程池來利用線程。線程池可以實現異步來執行任務。

二 ThreadPoolExecutor類的介紹

1、構造方法

JUC包下的ThreadPoolExecutor類是線程池做核心的一個類，要搞懂線程池必須先了解這個類。
在ThreadPoolExecutor類中提供了四個構造方法：

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}

實際上，前三個構造器都調用了第四個構造器進行初始化工作

2、參數釋義

下面我們來看一下各個參數的含義：

corePoolSize: 核心池的大小，非常重要的一個參數。默認情況下，創建了線程池後線程池中並沒有線程，線程數量爲0，當有任務來之後，就會創建一個線程取執行任務，當線程池中的數目達到corePoolSize後，就會新來的任務放到任務緩存隊列中。
在構建線程池後我們可以調用prestartAllCoreThreads()或者prestartCoreThread()方法來預創建線程，在任務到來之前將線程創建好。
maximumPoolSize：線程池最大線程數，這個參數也是一個非常重要的參數，它表示在線程池中最多能創建多少個線程；什麼時候會用到這個參數下面會介紹到
keepAliveTime: 線程沒有任務執行時最多保持多久的時間會停止。
默認情況下，當線程池中的線程數大於核心線程數時，keepAliveTime纔會起作用，直到線程池中線程數不大於核心線程數。allowCoreThreadTimeOut(boolean)方法可以設置在線程池中線程數不大於核心池數時，keepAliveTime也起作用。
unit: keepAliveTime的時間單位，TimeUnit的靜態屬性。
workQueue：一個阻塞隊列，用來存儲等待執行的任務，這個參數的選擇也很重要，會對線程池的運行過程產生重大影響，一般來說，這裏的阻塞隊列有以下幾種選擇：
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;
這個參數與線程池的排隊策略有關。
threadFactory ：線程工廠，主要用來創建線程；
可以調用默認的線程工廠創建：

    /**
     * The default thread factory
     */
    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

handler : 表示任務的拒絕處理策略
ThreadPoolExecutor.AbortPolicy:丟棄任務並拋出RejectedExecutionException異常。
ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不拋出異常。
ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務，然後重新嘗試執行任務（重複此過程）
ThreadPoolExecutor.CallerRunsPolicy：由調用線程處理該任務

3、繼承關係

ThreadPoolExecutor -> AbstractExecutorService -> ExecutorService -> Executor

Executor 是一個頂層接口，裏面只有一個execute(Runnable)，返回值爲void，參數爲Runnable類型，從字面意思可以理解，就是用來執行傳進去的任務的

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

ExecutorService接口，聲明瞭submit、invokeAll、invokeAny以及shutDown等方法

public interface ExecutorService extends Executor {
 
    void shutdown();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
 
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

抽象類AbstractExecutorService實現了ExecutorService接口，基本實現了ExecutorService中聲明的所有方法
ThreadPoolExecutor繼承了類AbstractExecutorService

由此我們發現在ThreadPoolExecutor類中有幾個重要的方法：

execute()
submit()
shutdown()
shutdownNow()

execute : 這是一個核心方法，在Executor中就聲明瞭，它可以向線程池中提交一個任務，由線程池去執行
submit() ：向線程池提交任務，能夠返回任務的執行結果，由Future類來接收任務執行的結果。這個方法實際上還是調用了submit()方法，感興趣的同學可以看下這個方法的具體實現
shutdown()和shutdownNow()是用來關閉線程池的

還有很多有用的方法：
比如：getQueue() 、getPoolSize() 、getActiveCount()、getCompletedTaskCount()等獲取與線程池相關屬性的方法，有興趣的朋友可以自行查閱API。

三線程池的實現和執行原理

1、線程池的狀態

    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

使用**AtomicInteger **的CAS機制來實現對運行時狀態以及工作線程計數的併發一致性操作，低29位（32-3）用來保存workerCount，所以workerCount的最大爲2^29 -1 。高3位用來保存runState，這樣實現具有較高效率。

RUNNING : 當創建線程池後，初始時，線程池處於RUNNING狀態。處於該狀態的線程池可以接受新的任務，並且執行緩存任務隊列的任務
SHUTDOWN :　當調用了shutdown（）方法的時候，線程處於SHUTDOWN 方法。該狀態下不再接收新的任務，但是會執行緩存任務隊列中的任務
STOP : 調用了shutdownNow（）方法，則處於STOP狀態，此時線程池不能接受新的任務，也不執行緩存隊列中的任務，並且中斷正在運行的任務
TIDYING：所有的任務已經終止，workCount爲0，這個狀態爲暫時狀態，之後將調用terminated() hook method
TERMINATED ： terminated()方法調用完成線程處於該狀態

2、線程池的任務執行

TreadPoolExecutor類中還有一些比較重要的成員變量：

private final BlockingQueue<Runnable> workQueue;              //任務緩存隊列，用來存放等待執行的任務
private final ReentrantLock mainLock = new ReentrantLock();   //線程池的主要狀態鎖，對線程池狀態（比如線程池大小
                                                              //、runState等）的改變都要使用這個鎖
private final HashSet<Worker> workers = new HashSet<Worker>();  //用來存放工作集
 
private volatile long  keepAliveTime;    //線程存貨時間   
private volatile boolean allowCoreThreadTimeOut;   //是否允許爲核心線程設置存活時間
private volatile int   corePoolSize;     //核心池的大小（即線程池中的線程數目大於這個參數時，提交的任務會被放進任務緩存隊列）
private volatile int   maximumPoolSize;   //線程池最大能容忍的線程數
 
private volatile int   poolSize;       //線程池中當前的線程數
 
private volatile RejectedExecutionHandler handler; //任務拒絕策略
 
private volatile ThreadFactory threadFactory;   //線程工廠，用來創建線程
 
private int largestPoolSize;   //用來記錄線程池中曾經出現過的最大線程數
 
private long completedTaskCount;   //用來記錄已經執行完畢的任務個數

對於corePoolSize、maximumPoolSize、largestPoolSize三個變量重點講解一下：
corePoolSize是核心池大小，其實就是線程池的大小。舉個簡單的例子：
假如有一個工廠，工廠裏面有10個工人，每個工人同時只能做一件任務。
　　因此只要當10個工人中有工人是空閒的，來了任務就分配給空閒的工人做；
　　當10個工人都有任務在做時，如果還來了任務，就把任務進行排隊等待；
　　如果說新任務數目增長的速度遠遠大於工人做任務的速度，那麼此時工廠主管可能會想補救措施，比如重新招4個臨時工人進來；
　　然後就將任務也分配給這4個臨時工人做；
　　如果說着14個工人做任務的速度還是不夠，此時工廠主管可能就要考慮不再接收新的任務或者拋棄前面的一些任務了。
　　當這14個工人當中有人空閒時，而新任務增長的速度又比較緩慢，工廠主管可能就考慮辭掉4個臨時工了，只保持原來的10個工人，畢竟請額外的工人是要花錢的。
　　這個例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。
　　也就是說corePoolSize就是線程池大小，maximumPoolSize在我看來是線程池的一種補救措施，即任務量突然過大時的一種補救措施。
　　largestPoolSize只是一個用來起記錄作用的變量，用來記錄線程池中曾經有過的最大線程數目，跟線程池的容量沒有任何關係。

下面我們進入正題，看一下任務從提交到最終執行完成經歷了哪些過程
ThreadPoolExecutor類中最核心的execute（）方法，我們重點研究一下:

public void execute(Runnable command) {
   if (command == null)
       throw new NullPointerException();
   if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
       if (runState == RUNNING && workQueue.offer(command)) {
           if (runState != RUNNING || poolSize == 0)
               ensureQueuedTaskHandled(command);
       }
       else if (!addIfUnderMaximumPoolSize(command))
           reject(command); // is shutdown or saturated
   }
}

我們一句一句來分析上面的代碼：
首先，判斷提交的command是否爲null，如果是null，拋出空指針異常！
接着是下面的if語句：

if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))

或條件的前半句，如果線程池中的當前線程數不低於核心池大小，則進入if語句塊。
如果低於核心池大小，就要執行addIfUnderCorePoolSize(command)，根據方法名，可以想到大概的意思就是當低於核心池數大小的時候去添加任務。
如果addIfUnderCorePoolSize返回false就執行下面的if語句塊，否則方法執行完畢
如果執行完addIfUnderCorePoolSize這個方法返回false，然後接着判斷：

if (runState == RUNNING && workQueue.offer(command))

這個判斷是如果當前線程池處於RUNNING則將任務放到緩存隊列；如果不處於RUNNING或者放入緩存隊列失敗，則執行addIfUnderMaximumPoolSize(command)方法，如果執行addIfUnderMaximumPoolSize方法失敗，則執行reject()方法進行任務拒絕處理。
而如果線程處於RUNNING並且放入緩存成功，則繼續判斷：

if (runState != RUNNING || poolSize == 0)

這個判斷的目的是爲了防止在執行將任務放入緩存隊列的時候突然調用了SHUTDOWN方法關閉了線程池，或者是線程池不處於RUNNING狀態，執行ensureQueuedTaskHandled(command)，保證添加到任務緩存隊列的任務得到處理。

接着我們來看很關鍵的一個方法：addIfUnderCorePoolSize（）

private boolean addIfUnderCorePoolSize(Runnable firstTask) {
    Thread t = null;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (poolSize < corePoolSize && runState == RUNNING)
            t = addThread(firstTask);        //創建線程去執行firstTask任務   
        } finally {
        mainLock.unlock();
    }
    if (t == null)
        return false;
    t.start();
    return true;
}

addIfUnderCorePoolSize方法顧名思義，是低於核心池大小的時候去執行的方法。看一下具體實現。事先獲取到鎖，因爲這裏涉及到線程池狀態的變化，下面這個if語句的判斷，當前線程池的數目小於核心池，線程池處於RUNNING狀態在之前的邏輯都已經判斷過了，爲甚麼在這裏要再判斷一遍？因爲之前的判斷沒有加鎖，並且有可能其他線程調用了SHUTDOWN方法。然後執行，t = addThread(firstTask)，我們來看一下這個方法，傳進去一個任務，返回一個Thread類型，在下面啓動線程。
下面是addThread方法的實現：

private Thread addThread(Runnable firstTask) {
   Worker w = new Worker(firstTask);
   Thread t = threadFactory.newThread(w);  //創建一個線程，執行任務   
   if (t != null) {
       w.thread = t;            //將創建的線程的引用賦值爲w的成員變量       
       workers.add(w);
       int nt = ++poolSize;     //當前線程數加1       
       if (nt > largestPoolSize)
           largestPoolSize = nt;
   }
   return t;
}

在這個方法中，首先用提交的任務創建了一個Worker對象，然後調用線程工廠threadFactory創建了一個新的線程t，然後將線程t的引用賦值給了Worker對象的成員變量thread，接着通過workers.add(w)將Worker對象添加到工作集當中。
Worker類實現了Runnable接口，實際上上面的方法就是相當於傳進去一個Runable任務在創建出來的線程t裏面執行。具體源碼：

private final class Worker implements Runnable {
    private final ReentrantLock runLock = new ReentrantLock();
    private Runnable firstTask;
    volatile long completedTasks;
    Thread thread;
    Worker(Runnable firstTask) {
        this.firstTask = firstTask;
    }
    boolean isActive() {
        return runLock.isLocked();
    }
    void interruptIfIdle() {
        final ReentrantLock runLock = this.runLock;
        if (runLock.tryLock()) {
            try {
        if (thread != Thread.currentThread())
        thread.interrupt();
            } finally {
                runLock.unlock();
            }
        }
    }
    void interruptNow() {
        thread.interrupt();
    }
 
    private void runTask(Runnable task) {
        final ReentrantLock runLock = this.runLock;
        runLock.lock();
        try {
            if (runState < STOP &&
                Thread.interrupted() &&
                runState >= STOP)
            boolean ran = false;
            beforeExecute(thread, task);   //beforeExecute方法是ThreadPoolExecutor類的一個方法，沒有具體實現，用戶可以根據
            //自己需要重載這個方法和後面的afterExecute方法來進行一些統計信息，比如某個任務的執行時間等           
            try {
                task.run();
                ran = true;
                afterExecute(task, null);
                ++completedTasks;
            } catch (RuntimeException ex) {
                if (!ran)
                    afterExecute(task, ex);
                throw ex;
            }
        } finally {
            runLock.unlock();
        }
    }
 
    public void run() {
        try {
            Runnable task = firstTask;
            firstTask = null;
            while (task != null || (task = getTask()) != null) {
                runTask(task);
                task = null;
            }
        } finally {
            workerDone(this);   //當任務隊列中沒有任務時，進行清理工作       
        }
    }
}

既然Worker實現了Runnable接口，那麼自然最核心的方法便是run()方法了（）：

public void run() {
    try {
        Runnable task = firstTask;
        firstTask = null;
        while (task != null || (task = getTask()) != null) {
            runTask(task);
            task = null;
        }
    } finally {
        workerDone(this);
    }
}

從run方法的實現可以看出，它首先執行的是通過構造器傳進來的任務firstTask，在調用runTask()執行完firstTask之後，在while循環裏面不斷通過getTask()去取新的任務來執行，那麼去哪裏取呢？自然是從任務緩存隊列裏面去取，getTask是ThreadPoolExecutor類中的方法，並不是Worker類中的方法，下面是getTask方法的實現：

Runnable getTask() {
    for (;;) {
        try {
            int state = runState;
            if (state > SHUTDOWN)
                return null;
            Runnable r;
            if (state == SHUTDOWN)  // Help drain queue
                r = workQueue.poll();
            else if (poolSize > corePoolSize || allowCoreThreadTimeOut) //如果線程數大於核心池大小或者允許爲核心池線程設置空閒時間，
                //則通過poll取任務，若等待一定的時間取不到任務，則返回null
                r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
            else
                r = workQueue.take();
            if (r != null)
                return r;
            if (workerCanExit()) {    //如果沒取到任務，即r爲null，則判斷當前的worker是否可以退出
                if (runState >= SHUTDOWN) // Wake up others
                    interruptIdleWorkers();   //中斷處於空閒狀態的worker
                return null;
            }
            // Else retry
        } catch (InterruptedException ie) {
            // On interruption, re-check runState
        }
    }
}

在getTask中，先判斷當前線程池狀態，如果runState大於SHUTDOWN（即爲STOP或者TERMINATED），則直接返回null。

如果runState爲SHUTDOWN或者RUNNING，則從任務緩存隊列取任務。

如果當前線程池的線程數大於核心池大小corePoolSize或者允許爲核心池中的線程設置空閒存活時間，則調用poll(time,timeUnit)來取任務，這個方法會等待一定的時間，如果取不到任務就返回null。

然後判斷取到的任務r是否爲null，爲null則通過調用workerCanExit()方法來判斷當前worker是否可以退出，我們看一下workerCanExit()的實現：

private boolean workerCanExit() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    boolean canExit;
    //如果runState大於等於STOP，或者任務緩存隊列爲空了
    //或者  允許爲核心池線程設置空閒存活時間並且線程池中的線程數目大於1
    try {
        canExit = runState >= STOP ||
            workQueue.isEmpty() ||
            (allowCoreThreadTimeOut &&
             poolSize > Math.max(1, corePoolSize));
    } finally {
        mainLock.unlock();
    }
    return canExit;
}

也就是說如果線程池處於STOP狀態、或者任務隊列已爲空或者允許爲核心池線程設置空閒存活時間並且線程數大於1時，允許worker退出。如果允許worker退出，則調用interruptIdleWorkers()中斷處於空閒狀態的worker，我們看一下interruptIdleWorkers()的實現：

void interruptIdleWorkers() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers)  //實際上調用的是worker的interruptIfIdle()方法
            w.interruptIfIdle();
    } finally {
        mainLock.unlock();
    }
}

從實現可以看出，它實際上調用的是worker的interruptIfIdle()方法，在worker的interruptIfIdle()方法中：

void interruptIfIdle() {
    final ReentrantLock runLock = this.runLock;
    if (runLock.tryLock()) {    //注意這裏，是調用tryLock()來獲取鎖的，因爲如果當前worker正在執行任務，鎖已經被獲取了，是無法獲取到鎖的
                                //如果成功獲取了鎖，說明當前worker處於空閒狀態
        try {
    if (thread != Thread.currentThread())  
    thread.interrupt();
        } finally {
            runLock.unlock();
        }
    }
}

這裏有一個非常巧妙的設計方式，假如我們來設計線程池，可能會有一個任務分派線程，當發現有線程空閒時，就從任務緩存隊列中取一個任務交給空閒線程執行。但是在這裏，並沒有採用這樣的方式，因爲這樣會要額外地對任務分派線程進行管理，無形地會增加難度和複雜度，這裏直接讓執行完任務的線程去任務緩存隊列裏面取任務來執行。
我們再看addIfUnderMaximumPoolSize方法的實現，這個方法的實現思想和addIfUnderCorePoolSize方法的實現思想非常相似，唯一的區別在於addIfUnderMaximumPoolSize方法是在線程池中的線程數達到了核心池大小並且往任務隊列中添加任務失敗的情況下執行的：

private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
    Thread t = null;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (poolSize < maximumPoolSize && runState == RUNNING)
            t = addThread(firstTask);
    } finally {
        mainLock.unlock();
    }
    if (t == null)
        return false;
    t.start();
    return true;
}

看到沒有，其實它和addIfUnderCorePoolSize方法的實現基本一模一樣，只是if語句判斷條件中的poolSize < maximumPoolSize不同而已。

到這裏，大部分朋友應該對任務提交給線程池之後到被執行的整個過程有了一個基本的瞭解，下面總結一下：

1）首先，要清楚corePoolSize和maximumPoolSize的含義；

2）其次，要知道Worker是用來起到什麼作用的；

3）要知道任務提交給線程池之後的處理策略，這裏總結一下主要有4點：

如果當前線程池中的線程數目小於corePoolSize，則每來一個任務，就會創建一個線程去執行這個任務；
如果當前線程池中的線程數目>=corePoolSize，則每來一個任務，會嘗試將其添加到任務緩存隊列當中，若添加成功，則該任務會等待空閒線程將其取出去執行；若添加失敗（一般來說是任務緩存隊列已滿），則會嘗試創建新的線程去執行這個任務；
如果當前線程池中的線程數目達到maximumPoolSize，則會採取任務拒絕策略進行處理；
如果線程池中的線程數量大於 corePoolSize時，如果某線程空閒時間超過keepAliveTime，線程將被終止，直至線程池中的線程數目不大於corePoolSize；如果允許爲核心池中的線程設置存活時間，那麼核心池中的線程空閒時間超過keepAliveTime，線程也會被終止。

3、線程池中的線程初始化

默認情況下，創建線程池之後，線程池中是沒有線程的，需要提交任務之後纔會創建線程。

在實際中如果需要線程池創建之後立即創建線程，可以通過以下兩個方法辦到：

prestartCoreThread()：初始化一個核心線程；
prestartAllCoreThreads()：初始化所有核心線程

public boolean prestartCoreThread() {
    return addIfUnderCorePoolSize(null); //注意傳進去的參數是null
}
 
public int prestartAllCoreThreads() {
    int n = 0;
    while (addIfUnderCorePoolSize(null))//注意傳進去的參數是null
        ++n;
    return n;
}

注意上面傳進去的參數是null，根據第2小節的分析可知如果傳進去的參數爲null，則最後執行線程會阻塞在getTask方法中的r = workQueue.take();即等待任務隊列中有任務。

4.任務緩存隊列及排隊策略

在前面我們多次提到了任務緩存隊列，即workQueue，它用來存放等待執行的任務。
　　workQueue的類型爲BlockingQueue，通常可以取下面三種類型：
　　1）ArrayBlockingQueue：基於數組的先進先出隊列，此隊列創建時必須指定大小；
　　2）LinkedBlockingQueue：基於鏈表的先進先出隊列，如果創建時沒有指定此隊列大小，則默認爲Integer.MAX_VALUE；
　　3）synchronousQueue：這個隊列比較特殊，它不會保存提交的任務，而是將直接新建一個線程來執行新來的任務。

5.任務拒絕策略

當線程池的任務緩存隊列已滿並且線程池中的線程數目達到maximumPoolSize，如果還有任務到來就會採取任務拒絕策略，通常有以下四種策略：

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

6.線程池的關閉

ThreadPoolExecutor提供了兩個方法，用於線程池的關閉，分別是shutdown()和shutdownNow()，其中：

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

7.線程池容量的動態調整

ThreadPoolExecutor提供了動態調整線程池容量大小的方法：setCorePoolSize()和setMaximumPoolSize()，
setCorePoolSize：設置核心池大小
setMaximumPoolSize：設置線程池最大能創建的線程數目大小
　　當上述參數從小變大時，ThreadPoolExecutor進行線程賦值，還可能立即創建新的線程來執行任務。

四線程池的使用示例

前面我們討論了關於線程池的實現原理，這一節我們來看一下它的具體使用：

public class TestJson {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(5));

        for (int i = 0; i < 15; i++) {
            MyTask myTask = new MyTask(i);
            executor.execute(myTask);
            System.out.println("線程池中線程數目：" + executor.getPoolSize() + "，隊列中等待執行的任務數目：" +
                    executor.getQueue().size() + "，已執行玩別的任務數目：" + executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }

static class MyTask implements Runnable {
    private int taskNum;

    public MyTask(int num) {
        this.taskNum = num;
    }

    @Override
    public void run() {
        System.out.println("正在執行task " + taskNum);
        try {
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task " + taskNum + "執行完畢");
    }
}
}

執行結果：

線程池中線程數目：1，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
線程池中線程數目：2，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 0
線程池中線程數目：3，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
線程池中線程數目：4，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
線程池中線程數目：5，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 1
線程池中線程數目：5，隊列中等待執行的任務數目：1，已執行玩別的任務數目：0
線程池中線程數目：5，隊列中等待執行的任務數目：2，已執行玩別的任務數目：0
線程池中線程數目：5，隊列中等待執行的任務數目：3，已執行玩別的任務數目：0
線程池中線程數目：5，隊列中等待執行的任務數目：4，已執行玩別的任務數目：0
線程池中線程數目：5，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 2
線程池中線程數目：6，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
線程池中線程數目：7，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
線程池中線程數目：8，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
線程池中線程數目：9，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
線程池中線程數目：10，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 3
正在執行task 4
正在執行task 10
正在執行task 11
正在執行task 12
正在執行task 13
正在執行task 14
task 2執行完畢
task 0執行完畢
正在執行task 6
task 1執行完畢
正在執行task 7
正在執行task 5
task 3執行完畢
正在執行task 8
task 4執行完畢
正在執行task 9
task 12執行完畢
task 10執行完畢
task 11執行完畢
task 13執行完畢
task 14執行完畢
task 7執行完畢
task 6執行完畢
task 5執行完畢
task 8執行完畢
task 9執行完畢

從執行結果可以看出，當線程池中線程的數目大於5時，便將任務放入任務緩存隊列裏面，當任務緩存隊列滿了之後，便創建新的線程。如果上面程序中，將for循環中改成執行20個任務，就會拋出任務拒絕異常了。

不過在java doc中，並不提倡我們直接使用ThreadPoolExecutor，而是使用Executors類中提供的幾個靜態方法來創建線程池：

Executors.newCachedThreadPool();        //創建一個緩衝池，緩衝池容量大小爲Integer.MAX_VALUE
Executors.newSingleThreadExecutor();   //創建容量爲1的緩衝池
Executors.newFixedThreadPool(int);    //創建固定容量大小的緩衝池

下面是這三個靜態方法的具體實現;

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

從它們的具體實現來看，它們實際上也是調用了ThreadPoolExecutor，只不過參數都已配置好了。
　　newFixedThreadPool創建的線程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue；
　　newSingleThreadExecutor將corePoolSize和maximumPoolSize都設置爲1，也使用的LinkedBlockingQueue；
　　newCachedThreadPool將corePoolSize設置爲0，將maximumPoolSize設置爲Integer.MAX_VALUE，使用的SynchronousQueue，也就是說來了任務就創建線程運行，當線程空閒超過60秒，就銷燬線程。
　　實際中，如果Executors提供的三個靜態方法能滿足要求，就儘量使用它提供的三個方法，因爲自己去手動配置ThreadPoolExecutor的參數有點麻煩，要根據實際任務的類型和數量來進行配置。
　　另外，如果ThreadPoolExecutor達不到要求，可以自己繼承ThreadPoolExecutor類進行重寫。

五如何合理配置線程池的大小

下面討論一個比較重要的話題：如何合理配置線程池大小，僅供參考。

一般需要根據任務的類型來配置線程池大小：

如果是CPU密集型任務，就需要儘量壓榨CPU，參考值可以設爲 NCPU+1

如果是IO密集型任務，參考值可以設置爲2*NCPU

當然，這只是一個參考值，具體的設置還需要根據實際情況進行調整，比如可以先將線程池大小設置爲參考值，再觀察任務運行情況和系統負載、資源利用率來進行適當調整。

瓶子君JK

發佈了5 篇原創文章 · 獲贊 4 · 訪問量 2254

私信關注

JAVA線程池的原理及使用

JAVA線程池的原理及使用

一使用線程池的原因

二 ThreadPoolExecutor類的介紹

1、構造方法

2、參數釋義

3、繼承關係

三線程池的實現和執行原理

1、線程池的狀態

2、線程池的任務執行

3、線程池中的線程初始化

4.任務緩存隊列及排隊策略

5.任務拒絕策略

6.線程池的關閉

7.線程池容量的動態調整

四線程池的使用示例

五如何合理配置線程池的大小

JAVA併發編程-1-線程基礎

JAVA線程池的原理及使用

《深入理解Java虛擬機：JVM高級特性與最佳實踐》書評

JAVA處理數據不存在插入存在更新

深入淺出：Mysql索引底層原理

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

JAVA線程池的原理及使用

JAVA線程池的原理及使用

一 使用線程池的原因

二 ThreadPoolExecutor類的介紹

1、構造方法

2、參數釋義

3、繼承關係

三 線程池的實現和執行原理

1、線程池的狀態

2、線程池的任務執行

3、線程池中的線程初始化

4.任務緩存隊列及排隊策略

5.任務拒絕策略

6.線程池的關閉

7.線程池容量的動態調整

四 線程池的使用示例

五 如何合理配置線程池的大小

一使用線程池的原因

三線程池的實現和執行原理

四線程池的使用示例

五如何合理配置線程池的大小