歡迎光臨
每天分享高質量文章

如何擴展和優化執行緒池?

精品專欄

 

作者:莫那·魯道
出處:併發編程之執行緒池的使用及擴展和優化


多執行緒的軟體設計方法確實可以最大限度的發揮現代多核處理器的計算能力,提高生產系統的吞吐量和性能。但是,如果一個系統同時創建大量執行緒,執行緒間頻繁的切換背景關係導致的系統開銷將會拖慢整個系統。嚴重的甚至導致記憶體耗盡導致OOM異常。因此,在實際的生產環境中,執行緒的數量必須得到控制,盲目的創建大量新車對系統是有傷害的。

那麼,怎麼才能最大限度的利用CPU的性能,又能保持系統的穩定性呢?其中有一個方法就是使用執行緒池。

簡而言之,在使用執行緒池後,創建執行緒便處理從執行緒池獲得空閑執行緒,關閉執行緒變成了向池子歸還執行緒。也就是說,提高了執行緒的復用。

而 JDK 在 1.5 之後為我提供了現成的執行緒池工具,我們今天就來學習看看如何使用他們。

  1. Executors 執行緒池工廠能創建哪些執行緒池

  2. 如何手動創建執行緒池

  3. 如何擴展執行緒池

  4. 如何優化執行緒池的異常信息

  5. 如何設計執行緒池中的執行緒數量

1. Executors 執行緒池工廠能創建哪些執行緒池

先來一個最簡單的執行緒池使用例子:

  1.  static class MyTask implements Runnable {

  2.    @Override

  3.    public void run() {

  4.      System.out

  5.          .println(System.currentTimeMillis() + ": Thread ID :" + Thread.currentThread().getId());

  6.      try {

  7.        Thread.sleep(1000);

  8.      } catch (InterruptedException e) {

  9.        e.printStackTrace();

  10.      }

  11.    }

  12.  }

  13.  public static void main(String[] args) {

  14.    MyTask myTask = new MyTask();

  15.    ExecutorService service1 = Executors.newFixedThreadPool(5);

  16.    for (int i = 0; i < 10; i++) {

  17.      service1.submit(myTask);

  18.    }

  19.    service1.shutdown();

  20.  }

運行結果:

我們創建了一個執行緒池實體,並設置預設執行緒數量為5,並向執行緒池提交了10任務,分別打印當前毫秒時間和執行緒ID,從結果中,我們可以看到結果中有5個相同 id 的執行緒打印了毫秒時間。

這是最簡單的例子。

接下來我們講講其他的執行緒創建方式。

1. 固定執行緒池 ExecutorService service1 = Executors.newFixedThreadPool(5); 該方法傳回一個固定執行緒數量的執行緒池。該執行緒池中的執行緒數量始終不變。當有一個新的任務提交時,執行緒池中若有空閑執行緒,則立即執行,若沒有,則新的任務會被暫存在一個任務佇列(預設無界佇列 int 最大數)中,待有執行緒空閑時,便處理在任務佇列中的任務。

2. 單例執行緒池 ExecutorService service3 = Executors.newSingleThreadExecutor(); 該方法傳回一個只有一個執行緒的執行緒池。若多餘一個任務被提交到該執行緒池,任務會被儲存在一個任務佇列(預設無界佇列 int 最大數)中,待執行緒空閑,按先入先出的順序執行佇列中的任務。

3. 快取執行緒池 ExecutorService service2 = Executors.newCachedThreadPool(); 該方法傳回一個可根據實際情況調整執行緒數量的執行緒池,執行緒池的執行緒數量不確定,但若有空閑執行緒可以復用,則會優先使用可復用的執行緒,所有執行緒均在工作,如果有新的任務提交,則會創建新的執行緒處理任務。所有執行緒在當前任務執行完畢後,將傳回執行緒池進行復用。

4. 任務呼叫執行緒池 ExecutorService service4 = Executors.newScheduledThreadPool(2); 該方法也傳回一個 ScheduledThreadPoolExecutor 物件,該執行緒池可以指定執行緒數量。

前3個執行緒的用法沒什麼差異,關鍵是第四個,雖然執行緒任務調度框架很多,但是我們仍然可以學習該執行緒池。如何使用呢?下麵來個例子:

  1. class A {

  2.  public static void main(String[] args) {

  3.    ScheduledThreadPoolExecutor service4 = (ScheduledThreadPoolExecutor) Executors

  4.        .newScheduledThreadPool(2);

  5.    // 如果前面的任務沒有完成,則調度也不會啟動

  6.    service4.scheduleAtFixedRate(new Runnable() {

  7.      @Override

  8.      public void run() {

  9.        try {

  10.          // 如果任務執行時間大於間隔時間,那麼就以執行時間為準(防止任務出現堆疊)。

  11.          Thread.sleep(10000);

  12.          System.out.println(System.currentTimeMillis() / 1000);

  13.        } catch (InterruptedException e) {

  14.          e.printStackTrace();

  15.        }

  16.      }// initialDelay(初始延遲) 表示第一次延時時間 ; period 表示間隔時間

  17.    }, 0, 2, TimeUnit.SECONDS);

  18.    service4.scheduleWithFixedDelay(new Runnable() {

  19.      @Override

  20.      public void run() {

  21.        try {

  22.          Thread.sleep(5000);

  23.          System.out.println(System.currentTimeMillis() / 1000);

  24.        } catch (InterruptedException e) {

  25.          e.printStackTrace();

  26.        }

  27.      }// initialDelay(初始延遲) 表示延時時間;delay + 任務執行時間 = 等於間隔時間 period

  28.    }, 0, 2, TimeUnit.SECONDS);

  29.    // 在給定時間,對任務進行一次調度

  30.    service4.schedule(new Runnable() {

  31.      @Override

  32.      public void run() {

  33.        System.out.println("5 秒之後執行 schedule");

  34.      }

  35.    }, 5, TimeUnit.SECONDS);

  36.  }

  37.  }

  38. }

上面的代碼創建了一個 ScheduledThreadPoolExecutor 任務調度執行緒池,分別呼叫了3個方法,需要著重解釋 scheduleAtFixedRate 和 scheduleWithFixedDelay 方法,這兩個方法的作用很相似,唯一的區別就是他們執行人物的間隔時間的計算方式,前者時間間隔演算法是根據指定的 period 時間和任務執行時間中取時間長的,後者取的是指定的 delay 時間 + 任務執行時間。如果同學們有興趣,可以將上面的代碼跑跑看。一樣便能看出端倪。

好了,JDK 給我們封裝了創建執行緒池的 4 個方法,但是,請註意,由於這些方法高度封裝,因此,如果使用不當,出了問題將無從排查,因此,我建議,程式員應到自己手動創建執行緒池,而手動創建的前提就是高度瞭解執行緒池的引數設置。那麼我們就來看看如何手動創建執行緒池。

2. 如何手動創建執行緒池

下麵是一個手動創建執行緒池的範本:

  1.  /**

  2.   * 預設5條執行緒(預設數量,即最少數量),

  3.   * 最大20執行緒(指定了執行緒池中的最大執行緒數量),

  4.   * 空閑時間0秒(當執行緒池梳理超過核心數量時,多餘的空閑時間的存活時間,即超過核心執行緒數量的空閑執行緒,在多長時間內,會被銷毀),

  5.   * 等待佇列長度1024,

  6.   * 執行緒名稱[MXR-Task-%d],方便回溯,

  7.   * 拒絕策略:當任務佇列已滿,丟擲RejectedExecutionException

  8.   * 異常。

  9.   */

  10.  private static ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 20, 0L,

  11.      TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1024)

  12.      , new ThreadFactoryBuilder().setNameFormat("My-Task-%d").build()

  13.      , new AbortPolicy()

  14.  );

我們看到,ThreadPoolExecutor 也就是執行緒池有 7 個引數,我們一起來好好看看:

  1. corePoolSize 執行緒池中核心執行緒數量

  2. maximumPoolSize 最大執行緒數量

  3. keepAliveTime 空閑時間(當執行緒池梳理超過核心數量時,多餘的空閑時間的存活時間,即超過核心執行緒數量的空閑執行緒,在多長時間內,會被銷毀)

  4. unit 時間單位

  5. workQueue 當核心執行緒工作已滿,需要儲存任務的佇列

  6. threadFactory 創建執行緒的工廠

  7. handler 當佇列滿了之後的拒絕策略

前面幾個引數我們就不講了,很簡單,主要是後面幾個引數,佇列,執行緒工廠,拒絕策略。

我們先看看佇列,執行緒池預設提供了 4 個佇列。

  1. 無界佇列: 預設大小 int 最大值,因此可能會耗盡系統記憶體,引起OOM,非常危險。

  2. 直接提交的佇列 : 沒有容量,不會儲存,直接創建新的執行緒,因此需要設置很大的執行緒池數。否則容易執行拒絕策略,也很危險。

  3. 有界佇列:如果core滿了,則儲存在佇列中,如果core滿了且佇列滿了,則創建執行緒,直到maximumPoolSize 到了,如果佇列滿了且最大執行緒數已經到了,則執行拒絕策略。

  4. 優先級佇列:按照優先級執行任務。也可以設置大小。

樓主在自己的專案中使用了無界佇列,但是設置了任務大小,1024。如果你的任務很多,建議分為多個執行緒池。不要把雞蛋放在一個籃子里。

再看看拒絕策略,什麼是拒絕策略呢?當佇列滿了,如何處理那些仍然提交的任務。JDK 預設有4種策略。

  1. AbortPolicy :直接丟擲異常,阻止系統正常工作.

  2. CallerRunsPolicy : 只要執行緒池未關閉,該策略直接在呼叫者執行緒中,運行當前被丟棄的任務。顯然這樣做不會真的丟棄任務,但是,任務提交執行緒的性能極有可能會急劇下降。

  3. DiscardOldestPolicy: 該策略將丟棄最老的一個請求,也就是即將被執行的一個任務,並嘗試再次提交當前任務.

  4. DiscardPolicy: 該策略默默地丟棄無法處理的任務,不予任何處理,如果允許任務丟失,我覺得這是最好的方案.

當然,如果你不滿意JDK提供的拒絕策略,可以自己實現,只需要實現 RejectedExecutionHandler 接口,並重寫 rejectedExecution 方法即可。

最後,執行緒工廠,執行緒池的所有執行緒都由執行緒工廠來創建,而預設的執行緒工廠太過單一,我們看看預設的執行緒工廠是如何創建執行緒的:

  1. /**

  2.     * The default thread factory

  3.     */

  4.    static class DefaultThreadFactory implements ThreadFactory {

  5.        private static final AtomicInteger poolNumber = new AtomicInteger(1);

  6.        private final ThreadGroup group;

  7.        private final AtomicInteger threadNumber = new AtomicInteger(1);

  8.        private final String namePrefix;

  9.        DefaultThreadFactory() {

  10.            SecurityManager s = System.getSecurityManager();

  11.            group = (s != null) ? s.getThreadGroup() :

  12.                                  Thread.currentThread().getThreadGroup();

  13.            namePrefix = "pool-" +

  14.                          poolNumber.getAndIncrement() +

  15.                         "-thread-";

  16.        }

  17.        public Thread newThread(Runnable r) {

  18.            Thread t = new Thread(group, r,

  19.                                  namePrefix + threadNumber.getAndIncrement(),

  20.                                  0);

  21.            if (t.isDaemon())

  22.                t.setDaemon(false);

  23.            if (t.getPriority() != Thread.NORM_PRIORITY)

  24.                t.setPriority(Thread.NORM_PRIORITY);

  25.            return t;

  26.        }

  27.    }

可以看到,執行緒名稱為 pool- + 執行緒池編號 + -thread- + 執行緒編號 。設置為非守護執行緒。優先級為預設。

如果我們想修改名稱呢?對,實現 ThreadFactory 接口,重寫 newThread 方法即可。但是已經有人造好輪子了, 比如我們的例子中使用的 google 的 guaua 提供的 ThreadFactoryBuilder 工廠。可以自定義執行緒名稱,是否守護,優先級,異常處理等等,功能強大。

3. 如何擴展執行緒池

那麼我們能擴展執行緒池的功能嗎?比如記錄執行緒任務的執行時間。實際上,JDK 的執行緒池已經為我們預留的接口,在執行緒池核心方法中,有2 個方法是空的,就是給我們預留的。還有一個執行緒池退出時會呼叫的方法。我們看看例子:

  1. /**

  2. * 如何擴展執行緒池,重寫 beforeExecute, afterExecute, terminated 方法,這三個方法預設是空的。

  3. *

  4. * 可以監控每個執行緒任務執行的開始和結束時間,或者自定義一些增強。

  5. *

  6. * 在 Worker 的 runWork 方法中,會呼叫這些方法

  7. */

  8. public class ExtendThreadPoolDemo {

  9.  static class MyTask implements Runnable {

  10.    String name;

  11.    public MyTask(String name) {

  12.      this.name = name;

  13.    }

  14.    @Override

  15.    public void run() {

  16.      System.out

  17.          .println("正在執行:Thread ID:" + Thread.currentThread().getId() + ", Task Name = " + name);

  18.      try {

  19.        Thread.sleep(100);

  20.      } catch (InterruptedException e) {

  21.        e.printStackTrace();

  22.      }

  23.    }

  24.  }

  25.  public static void main(String[] args) throws InterruptedException {

  26.    ExecutorService es = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,

  27.        new LinkedBlockingQueue<>()) {

  28.      @Override

  29.      protected void beforeExecute(Thread t, Runnable r) {

  30.        System.out.println("準備執行:" + ((MyTask) r).name);

  31.      }

  32.      @Override

  33.      protected void afterExecute(Runnable r, Throwable t) {

  34.        System.out.println("執行完成: " + ((MyTask) r).name);

  35.      }

  36.      @Override

  37.      protected void terminated() {

  38.        System.out.println("執行緒池退出");

  39.      }

  40.    };

  41.    for (int i = 0; i < 5; i++) {

  42.      MyTask myTask = new MyTask("TASK-GEYM-" + i);

  43.      es.execute(myTask);

  44.      Thread.sleep(10);

  45.    }

  46.    es.shutdown();

  47.  }

  48. }

我們重寫了 beforeExecute 方法,也就是執行任務之前會呼叫該方法,而 afterExecute 方法則是在任務執行完畢後會呼叫該方法。還有一個 terminated 方法,在執行緒池退出時會呼叫該方法。執行結果是什麼呢?

可以看到,每個任務執行前後都會呼叫 before 和 after 方法。相當於執行了一個切麵。而在呼叫 shutdown 方法後則會呼叫 terminated 方法。

4. 如何優化執行緒池的異常信息

如何優化執行緒池的異常信息? 在說這個問題之前,我們先說一個不容易發現的bug:

看代碼:

  1.  public static void main(String[] args) throws ExecutionException, InterruptedException {

  2.    ThreadPoolExecutor executor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0L,

  3.        TimeUnit.MILLISECONDS, new SynchronousQueue<>());

  4.    for (int i = 0; i < 5; i++) {

  5.      executor.submit(new DivTask(100, i));

  6.    }

  7.  }

  8.  static class DivTask implements Runnable {

  9.    int a, b;

  10.    public DivTask(int a, int b) {

  11.      this.a = a;

  12.      this.b = b;

  13.    }

  14.    @Override

  15.    public void run() {

  16.      double re = a / b;

  17.      System.out.println(re);

  18.    }

  19.  }

執行結果:

註意:只有4個結果,其中一個結果被吞沒了,並且沒有任何信息。為什麼呢?如果仔細看代碼,會發現,在進行 100 / 0 的時候肯定會報錯的,但是卻沒有報錯信息,令人頭痛,為什麼呢?實際上,如果你使用 execute 方法則會打印錯誤信息,當你使用 submit 方法卻沒有呼叫它的get 方法,異常將會被吞沒,因為,如果發生了異常,異常是作為傳回值傳回的。

怎麼辦呢?我們當然可以使用 execute 方法,但是我們可以有另一種方式:重寫 submit 方法,樓主寫了一個例子,大家看一下:

  1.  static class TraceThreadPoolExecutor extends ThreadPoolExecutor {

  2.    public TraceThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,

  3.        TimeUnit unit, BlockingQueue<Runnable> workQueue) {

  4.      super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

  5.    }

  6.    @Override

  7.    public void execute(Runnable command) {

  8. //      super.execute(command);

  9.      super.execute(wrap(command, clientTrace(), Thread.currentThread().getName()));

  10.    }

  11.    @Override

  12.    public Future> submit(Runnable task) {

  13. //      return super.submit(task);

  14.      return super.submit(wrap(task, clientTrace(), Thread.currentThread().getName()));

  15.    }

  16.    private Exception clientTrace() {

  17.      return new Exception("Client stack trace");

  18.    }

  19.    private Runnable wrap(final Runnable task, final Exception clientStack,

  20.        String clientThreaName) {

  21.      return new Runnable() {

  22.        @Override

  23.        public void run() {

  24.          try {

  25.            task.run();

  26.          } catch (Exception e) {

  27.            e.printStackTrace();

  28.            clientStack.printStackTrace();

  29.            throw e;

  30.          }

  31.        }

  32.      };

  33.    }

  34.  }

我們重寫了 submit 方法,封裝了異常信息,如果發生了異常,將會打印堆棧信息。我們看看使用重寫後的執行緒池後的結果是什麼?

從結果中,我們清楚的看到了錯誤信息的原因:by zero!並且堆棧信息明確,方便排錯。優化了預設執行緒池的策略。

5. 如何設計執行緒池中的執行緒數量

執行緒池的大小對系統的性能有一定的影響,過大或者過小的執行緒數量都無法發揮最優的系統性能,但是執行緒池大小的確定也不需要做的非常精確。因為只要避免極大和極小兩種情況,執行緒池的大小對性能的影響都不會影響太大,一般來說,確定執行緒池的大小需要考慮CPU數量,記憶體大小等因素,在《Java Concurrency in Practice》 書中給出了一個估算執行緒池大小的經驗公式:

公式還是有點複雜的,簡單來說,就是如果你是CPU密集型運算,那麼執行緒數量和CPU核心數相同就好,避免了大量無用的切換執行緒背景關係,如果你是IO密集型的話,需要大量等待,那麼執行緒數可以設置的多一些,比如CPU核心乘以2.

至於如何獲取 CPU 核心數,Java 提供了一個方法:

Runtime.getRuntime().availableProcessors();

傳回了CPU的核心數量。

總結

好了,到這裡,我們已經對如何使用執行緒池有了一個認識,這裡,樓主建議大家手動創建執行緒池,這樣對執行緒池中的各個引數可以有精準的瞭解,在對系統進行排錯或者調優的時候有好處。比如設置核心執行緒數多少合適,最大執行緒數,拒絕策略,執行緒工廠,佇列的大小和型別等等,也可以是G家的執行緒工廠自定義執行緒。

END


>>>>>> 加群交流技術 <<<<<<

赞(0)

分享創造快樂

© 2021 知識星球   网站地图