java自帶的四種執行緒池

明天喝可樂發表於2022-04-25
Java執行緒

java預定義的哪四種執行緒池？

  • newSingleThreadExexcutor：單執行緒數的執行緒池（核心執行緒數=最大執行緒數=1）
  • newFixedThreadPool：固定執行緒數的執行緒池（核心執行緒數=最大執行緒數=自定義）
  • newCacheThreadPool：可快取的執行緒池（核心執行緒數=0，最大執行緒數=Integer.MAX_VALUE）
  • newScheduledThreadPool：支援定時或週期任務的執行緒池（核心執行緒數=自定義，最大執行緒數=Integer.MAX_VALUE）

四種執行緒池有什麼區別？

上面四種執行緒池類都繼承ThreadPoolExecutor，在建立時都是直接返回new ThreadPoolExecutor(引數)，它們的區別是定義的ThreadPoolExecutor(引數)中引數不同，而ThreadPoolExecutor又繼承ExecutorService介面類

  • newFixedThreadPool
定義：
ExecutorService executorService=Executors.newFixedThreadPool(2);

image

缺點：使用了LinkBlockQueue的連結串列型阻塞佇列，當任務的堆積速度大於處理速度時，容易堆積任務而導致OOM記憶體溢位

  • newSingleThreadExecutor
定義：ExecutorService executorService =Executors.newSingleThreadExecutor();

image

上面程式碼神似new FixedThreadPoop(1)，但又有區別，因為外面多了一層FinalizableDelegatedExecutorService，其作用：
image

可知，fixedExecutorService的本質是ThreadPoolExecutor,所以fixedExecutorService可以強轉成ThreadPoolExecutor，但singleExecutorService與ThreadPoolExecutor無任何關係，所以強轉失敗，故newSingleThreadExecutor()被建立後，無法再修改其執行緒池引數，真正地做到single單個執行緒。

缺點：使用了LinkBlockQueue的連結串列型阻塞佇列，當任務的堆積速度大於處理速度時，容易堆積任務而導致OOM記憶體溢位

  • newCacheThreadPool
定義：ExecutorService executorService=Executors.newCacheThreadPool();

image

缺點：SynchronousQueue是BlockingQueue的一種實現，它也是一個佇列，因為最大執行緒數為Integer.MAX_VALUE，所有當執行緒過多時容易OOM記憶體溢位

  • ScheduledThreadPool
定義：ExecutorService executorService=Executors.newScheduledThreadPool(2);

原始碼：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        //ScheduledThreadPoolExecutor繼承ThreadPoolExecutor
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    
public ScheduledThreadPoolExecutor(int corePoolSize) {
    //ScheduledThreadPoolExecutor繼承ThreadPoolExecutor，故super()會呼叫ThreadPoolExecutor的建構函式初始化並返回一個ThreadPoolExecutor，而ThreadPoolExecutor使實現ExecutorService介面的
    //最終ScheduledThreadPoolExecutor也和上面幾種執行緒池一樣返回的是ExecutorService介面的實現類ThreadPoolExecutor
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

執行緒池有哪幾個重要引數？

ThreadPoolExecutor構造方法如下：

image

image

  • keepAliveTime是指當前執行緒數位於 [核心執行緒數,最大執行緒數] 之間的這些非核心執行緒等待多久空閒時間而沒有活幹時，就退出執行緒池；
  • 等待丟列的大小與最大執行緒數是沒有任何關係的，執行緒建立優先順序=核心執行緒 > 阻塞佇列 > 擴容的執行緒(當前核心執行緒數小於最大執行緒數時才能擴容執行緒)
  • 假如核心執行緒數5，等待佇列長度為3，最大執行緒數10：當執行緒數不斷在增加時，先建立5個核心執行緒，核心執行緒數滿了再把執行緒丟進等待丟列，等待佇列滿了(3個執行緒)，此時會比較最大執行緒數（只有等待丟列滿了最大執行緒數才能出場），還可以繼續建立2個執行緒（5+3+2），若執行緒數超過了最大執行緒數，則執行拒絕策略；
  • 假如核心執行緒數5，等待佇列長度為3，最大執行緒數7：當執行緒數不斷在增加時，先建立5個核心執行緒，核心執行緒數滿了再把執行緒丟進等待丟列，當等待佇列中有2個執行緒時達到了最大執行緒數(5+2=7)，但是等待丟列還沒滿所以不用管最大執行緒數，直到等待丟列滿了（3個阻塞執行緒），此時會比較最大執行緒數（只有等待丟列滿了最大執行緒數才能出場），此時核心+等待丟列=5+3=8>7=最大執行緒數，即已經達到最大執行緒數了，則執行拒絕策略；
  • 如果把等待丟列設定為LinkedBlockingQueue無界丟列，這個丟列是無限大的，就永遠不會走到判斷最大執行緒數那一步了

如何自定義執行緒池

可以使用有界佇列，自定義執行緒建立工廠ThreadFactory和拒絕策略handler來自定義執行緒池

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException, IOException {
        int corePoolSize = 2;
        int maximumPoolSize = 4;
        long keepAliveTime = 10;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
        ThreadFactory threadFactory = new NameTreadFactory();
        RejectedExecutionHandler handler = new MyIgnorePolicy();
       ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue, threadFactory, handler);
        executor.prestartAllCoreThreads(); // 預啟動所有核心執行緒        
        for (int i = 1; i <= 10; i++) {
            MyTask task = new MyTask(String.valueOf(i));
            executor.execute(task);
        }
        System.in.read(); //阻塞主執行緒
    }
    static class NameTreadFactory implements ThreadFactory {
        private final AtomicInteger mThreadNum = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }

    public static class MyIgnorePolicy implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            doLog(r, e);
        }
        private void doLog(Runnable r, ThreadPoolExecutor e) {
            // 可做日誌記錄等
            System.err.println( r.toString() + " rejected");
//          System.out.println("completedTaskCount: " + e.getCompletedTaskCount());
        }
    }

    static class MyTask implements Runnable {
        private String name;
        public MyTask(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            try {
                System.out.println(this.toString() + " is running!");
                Thread.sleep(3000); //讓任務執行慢點
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public String getName() {
            return name;
        }
        @Override
        public String toString() {
            return "MyTask [name=" + name + "]";
        }
    }
}

執行結果：

image

其中7-10號執行緒被拒絕策略拒絕了，1、2號執行緒執行完後，3、6號執行緒進入核心執行緒池執行，此時4、5號執行緒在任務佇列等待執行，3、6執行緒執行完再通知4、5執行緒執行

相關文章