Java春招面試複習：執行緒池解析

前言

掌握執行緒池是後端程式設計師的基本要求，相信大家求職面試過程中，幾乎都會被問到有關於執行緒池的問題。我在網上搜集了幾道經典的執行緒池面試題，並以此為切入點，談談我對執行緒池的理解。如果有哪裡理解不正確，非常希望大家指出，接下來大家一起分析學習吧。

經典面試題

• 面試問題1：Java的執行緒池說一下，各個引數的作用，如何進行的?
• 面試問題2：按執行緒池內部機制，當提交新任務時，有哪些異常要考慮。
• 面試問題3：執行緒池都有哪幾種工作佇列？
• 面試問題4：使用無界佇列的執行緒池會導致記憶體飆升嗎？
• 面試問題5：說說幾種常見的執行緒池及使用場景?

執行緒池概念

執行緒池： 簡單理解，它就是一個管理執行緒的池子。

• 它幫我們管理執行緒，避免增加建立執行緒和銷燬執行緒的資源損耗。因為執行緒其實也是一個物件，建立一個物件，需要經過類載入過程，銷燬一個物件，需要走GC垃圾回收流程，都是需要資源開銷的。
• 提高響應速度。 如果任務到達了，相對於從執行緒池拿執行緒，重新去建立一條執行緒執行，速度肯定慢很多。
• 重複利用。 執行緒用完，再放回池子，可以達到重複利用的效果，節省資源。

執行緒池的建立

執行緒池可以通過ThreadPoolExecutor來建立，我們來看一下它的建構函式：

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime,TimeUnit unit,
   BlockingQueue<Runnable> workQueue,
   ThreadFactory threadFactory,
   RejectedExecutionHandler handler) 

幾個核心引數的作用：

• corePoolSize： 執行緒池核心執行緒數最大值
• maximumPoolSize： 執行緒池最大執行緒數大小
• keepAliveTime： 執行緒池中非核心執行緒空閒的存活時間大小
• unit： 執行緒空閒存活時間單位
• workQueue： 存放任務的阻塞佇列
• threadFactory： 用於設定建立執行緒的工廠，可以給建立的執行緒設定有意義的名字，可方便排查問題。
• handler： 線城池的飽和策略事件，主要有四種型別。

任務執行

執行緒池執行流程，即對應execute()方法：

• 提交一個任務，執行緒池裡存活的核心執行緒數小於執行緒數corePoolSize時，執行緒池會建立一個核心執行緒去處理提交的任務。
• 如果執行緒池核心執行緒數已滿，即執行緒數已經等於corePoolSize，一個新提交的任務，會被放進任務佇列workQueue排隊等待執行。
• 當執行緒池裡面存活的執行緒數已經等於corePoolSize了,並且任務佇列workQueue也滿，判斷執行緒數是否達到maximumPoolSize，即最大執行緒數是否已滿，如果沒到達，建立一個非核心執行緒執行提交的任務。
• 如果當前的執行緒數達到了maximumPoolSize，還有新的任務過來的話，直接採用拒絕策略處理。

四種拒絕策略

• AbortPolicy(丟擲一個異常，預設的)
• DiscardPolicy(直接丟棄任務)
• DiscardOldestPolicy（丟棄佇列裡最老的任務，將當前這個任務繼續提交給執行緒池）
• CallerRunsPolicy（交給執行緒池呼叫所在的執行緒進行處理)

為了形象描述執行緒池執行，我打個比喻：

• 核心執行緒比作公司正式員工
• 非核心執行緒比作外包員工
• 阻塞佇列比作需求池
• 提交任務比作提需求
  
• 當產品提個需求，正式員工（核心執行緒）先接需求（執行任務）
• 如果正式員工都有需求在做，即核心執行緒數已滿），產品就把需求先放需求池（阻塞佇列）。
• 如果需求池(阻塞佇列)也滿了，但是這時候產品繼續提需求,怎麼辦呢？那就請外包（非核心執行緒）來做。
• 如果所有員工（最大執行緒數也滿了）都有需求在做了，那就執行拒絕策略。
• 如果外包員工把需求做完了，它經過一段（keepAliveTime）空閒時間，就離開公司了。

好的，到這裡。面試問題1->Java的執行緒池說一下，各個引數的作用，如何進行的? 是否已經迎刃而解啦，
我覺得這個問題，回答：執行緒池建構函式的corePoolSize,maximumPoolSize等引數，並且能描述清楚執行緒池的執行流程 就差不多啦。

執行緒池異常處理

在使用執行緒池處理任務的時候，任務程式碼可能丟擲RuntimeException，丟擲異常後，執行緒池可能捕獲它，也可能建立一個新的執行緒來代替異常的執行緒，我們可能無法感知任務出現了異常，因此我們需要考慮執行緒池異常情況。

當提交新任務時，異常如何處理?

我們先來看一段程式碼：

       ExecutorService threadPool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            threadPool.submit(() -> {
                System.out.println("current thread name" + Thread.currentThread().getName());
                Object object = null;
                System.out.print("result## "+object.toString());
            });
        }

顯然，這段程式碼會有異常，我們再來看看執行結果

雖然沒有結果輸出，但是沒有丟擲異常，所以我們無法感知任務出現了異常，所以需要新增try/catch。
如下圖：

OK，執行緒的異常處理，我們可以直接try…catch捕獲。

執行緒池exec.submit(runnable)的執行流程

通過debug上面有異常的submit方法（建議大家也去debug看一下,圖上的每個方法內部是我打斷點的地方），處理有異常submit方法的主要執行流程圖：

  //構造feature物件
  /**
     * @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;
    }
     protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }
     public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }
       public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }
    //執行緒池執行
     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);
    }
    //捕獲異常
    public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }

通過以上分析，submit執行的任務，可以通過Future物件的get方法接收丟擲的異常，再進行處理。
我們再通過一個demo，看一下Future物件的get方法處理異常的姿勢，如下圖：

其他兩種處理執行緒池異常方案

除了以上1.在任務程式碼try/catch捕獲異常，2.通過Future物件的get方法接收丟擲的異常，再處理兩種方案外，還有以上兩種方案：

3.為工作者執行緒設定UncaughtExceptionHandler，在uncaughtException方法中處理異常

我們直接看這樣實現的正確姿勢：

ExecutorService threadPool = Executors.newFixedThreadPool(1, r -> {
            Thread t = new Thread(r);
            t.setUncaughtExceptionHandler(
                    (t1, e) -> {
                        System.out.println(t1.getName() + "執行緒丟擲的異常"+e);
                    });
            return t;
           });
        threadPool.execute(()->{
            Object object = null;
            System.out.print("result## " + object.toString());
        });

執行結果：

4.重寫ThreadPoolExecutor的afterExecute方法，處理傳遞的異常引用

這是jdk文件的一個demo：

class ExtendedExecutor extends ThreadPoolExecutor {
    // 這可是jdk文件裡面給的例子。。
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t == null && r instanceof Future<?>) {
            try {
                Object result = ((Future<?>) r).get();
            } catch (CancellationException ce) {
                t = ce;
            } catch (ExecutionException ee) {
                t = ee.getCause();
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt(); // ignore/reset
            }
        }
        if (t != null)
            System.out.println(t);
    }
}}

因此，被問到執行緒池異常處理，如何回答？

。

執行緒池的工作佇列

執行緒池都有哪幾種工作佇列？

• ArrayBlockingQueue
• LinkedBlockingQueue
• DelayQueue
• PriorityBlockingQueue
• SynchronousQueue

ArrayBlockingQueue

ArrayBlockingQueue（有界佇列）是一個用陣列實現的有界阻塞佇列，按FIFO排序量。

LinkedBlockingQueue

LinkedBlockingQueue（可設定容量佇列）基於連結串列結構的阻塞佇列，按FIFO排序任務，容量可以選擇進行設定，不設定的話，將是一個無邊界的阻塞佇列，最大長度為Integer.MAX_VALUE，吞吐量通常要高於ArrayBlockingQuene；newFixedThreadPool執行緒池使用了這個佇列

DelayQueue

DelayQueue（延遲佇列）是一個任務定時週期的延遲執行的佇列。根據指定的執行時間從小到大排序，否則根據插入到佇列的先後排序。newScheduledThreadPool執行緒池使用了這個佇列。

PriorityBlockingQueue

PriorityBlockingQueue（優先順序佇列）是具有優先順序的無界阻塞佇列；

SynchronousQueue

SynchronousQueue（同步佇列）一個不儲存元素的阻塞佇列，每個插入操作必須等到另一個執行緒呼叫移除操作，否則插入操作一直處於阻塞狀態，吞吐量通常要高於LinkedBlockingQuene，newCachedThreadPool執行緒池使用了這個佇列。

針對面試題：執行緒池都有哪幾種工作佇列？ 我覺得，回答以上幾種ArrayBlockingQueue，LinkedBlockingQueue，SynchronousQueue等，說出它們的特點，並結合使用到對應佇列的常用執行緒池(如newFixedThreadPool執行緒池使用LinkedBlockingQueue)，進行展開闡述， 就可以啦。

幾種常用的執行緒池

• newFixedThreadPool (固定數目執行緒的執行緒池)
• newCachedThreadPool(可快取執行緒的執行緒池)
• newSingleThreadExecutor(單執行緒的執行緒池)
• newScheduledThreadPool(定時及週期執行的執行緒池)

newFixedThreadPool

  public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }

執行緒池特點：

• 核心執行緒數和最大執行緒數大小一樣
• 沒有所謂的非空閒時間，即keepAliveTime為0
• 阻塞佇列為無界佇列LinkedBlockingQueue

工作機制：

• 提交任務
• 如果執行緒數少於核心執行緒，建立核心執行緒執行任務
• 如果執行緒數等於核心執行緒，把任務新增到LinkedBlockingQueue阻塞佇列
• 如果執行緒執行完任務，去阻塞佇列取任務，繼續執行。

例項程式碼

   ExecutorService executor = Executors.newFixedThreadPool(10);
                    for (int i = 0; i < Integer.MAX_VALUE; i++) {
                        executor.execute(()->{
                            try {
                                Thread.sleep(10000);
                            } catch (InterruptedException e) {
                                //do nothing
                            }
            });

IDE指定JVM引數：-Xmx8m -Xms8m :

run以上程式碼，會丟擲OOM：

因此，面試題：使用無界佇列的執行緒池會導致記憶體飆升嗎？

答案 ：會的，newFixedThreadPool使用了無界的阻塞佇列LinkedBlockingQueue，如果執行緒獲取一個任務後，任務的執行時間比較長(比如，上面demo設定了10秒)，會導致佇列的任務越積越多，導致機器記憶體使用不停飆升， 最終導致OOM。

使用場景

FixedThreadPool 適用於處理CPU密集型的任務，確保CPU在長期被工作執行緒使用的情況下，儘可能的少的分配執行緒，即適用執行長期的任務。

newCachedThreadPool

   public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
    }

執行緒池特點：

• 核心執行緒數為0
• 最大執行緒數為Integer.MAX_VALUE
• 阻塞佇列是SynchronousQueue
• 非核心執行緒空閒存活時間為60秒

當提交任務的速度大於處理任務的速度時，每次提交一個任務，就必然會建立一個執行緒。極端情況下會建立過多的執行緒，耗盡 CPU 和記憶體資源。由於空閒 60 秒的執行緒會被終止，長時間保持空閒的 CachedThreadPool 不會佔用任何資源。

工作機制

• 提交任務
• 因為沒有核心執行緒，所以任務直接加到SynchronousQueue佇列。
• 判斷是否有空閒執行緒，如果有，就去取出任務執行。
• 如果沒有空閒執行緒，就新建一個執行緒執行。
• 執行完任務的執行緒，還可以存活60秒，如果在這期間，接到任務，可以繼續活下去；否則，被銷燬。

例項程式碼

  ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName()+"正在執行");
            });
        }

執行結果：

使用場景

用於併發執行大量短期的小任務。

newSingleThreadExecutor

  public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }

執行緒池特點

• 核心執行緒數為1
• 最大執行緒數也為1
• 阻塞佇列是LinkedBlockingQueue
• keepAliveTime為0

工作機制

• 提交任務
• 執行緒池是否有一條執行緒在，如果沒有，新建執行緒執行任務
• 如果有，講任務加到阻塞佇列
• 當前的唯一執行緒，從佇列取任務，執行完一個，再繼續取，一個人（一條執行緒）夜以繼日地幹活。

例項程式碼

  ExecutorService executor = Executors.newSingleThreadExecutor();
                for (int i = 0; i < 5; i++) {
                    executor.execute(() -> {
                        System.out.println(Thread.currentThread().getName()+"正在執行");
                    });
        }

執行結果：

使用場景

適用於序列執行任務的場景，一個任務一個任務地執行。

newScheduledThreadPool

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

執行緒池特點

• 最大執行緒數為Integer.MAX_VALUE
• 阻塞佇列是DelayedWorkQueue
• keepAliveTime為0
• scheduleAtFixedRate() ：按某種速率週期執行
• scheduleWithFixedDelay()：在某個延遲後執行

工作機制

• 新增一個任務
• 執行緒池中的執行緒從 DelayQueue 中取任務
• 執行緒從 DelayQueue 中獲取 time 大於等於當前時間的task
• 執行完後修改這個 task 的 time 為下次被執行的時間
• 這個 task 放回DelayQueue佇列中

例項程式碼

    /**
    建立一個給定初始延遲的間隔性的任務，之後的下次執行時間是上一次任務從執行到結束所需要的時間+* 給定的間隔時間
    */
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
        scheduledExecutorService.scheduleWithFixedDelay(()->{
            System.out.println("current Time" + System.currentTimeMillis());
            System.out.println(Thread.currentThread().getName()+"正在執行");
        }, 1, 3, TimeUnit.SECONDS);

執行結果：

    /**
    建立一個給定初始延遲的間隔性的任務，之後的每次任務執行時間為 初始延遲 + N * delay(間隔) 
    */
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
            scheduledExecutorService.scheduleAtFixedRate(()->{
            System.out.println("current Time" + System.currentTimeMillis());
            System.out.println(Thread.currentThread().getName()+"正在執行");
        }, 1, 3, TimeUnit.SECONDS);;

使用場景

週期性執行任務的場景，需要限制執行緒數量的場景

回到面試題：說說幾種常見的執行緒池及使用場景？

回答這四種經典執行緒池 ：newFixedThreadPool，newSingleThreadExecutor，newCachedThreadPool，newScheduledThreadPool，分執行緒池特點，工作機制，使用場景分開描述，再分析可能存在的問題，比如newFixedThreadPool記憶體飆升問題 即可

執行緒池狀態

執行緒池有這幾個狀態：RUNNING,SHUTDOWN,STOP,TIDYING,TERMINATED。

   //執行緒池狀態
   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;

執行緒池各個狀態切換圖：

RUNNING

• 該狀態的執行緒池會接收新任務，並處理阻塞佇列中的任務;
• 呼叫執行緒池的shutdown()方法，可以切換到SHUTDOWN狀態;
• 呼叫執行緒池的shutdownNow()方法，可以切換到STOP狀態;

SHUTDOWN

• 該狀態的執行緒池不會接收新任務，但會處理阻塞佇列中的任務；
• 佇列為空，並且執行緒池中執行的任務也為空,進入TIDYING狀態;

STOP

• 該狀態的執行緒不會接收新任務，也不會處理阻塞佇列中的任務，而且會中斷正在執行的任務；
• 執行緒池中執行的任務為空,進入TIDYING狀態;

TIDYING

• 該狀態表明所有的任務已經執行終止，記錄的任務數量為0。
• terminated()執行完畢，進入TERMINATED狀態

TERMINATED

• 該狀態表示執行緒池徹底終止