線程池ThreadPoolExecutor使用簡介

1、簡介 
線程池類爲 java.util.concurrent.ThreadPoolExecutor,經常使用構造方法爲: 

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, 
long keepAliveTime, TimeUnit unit, 
BlockingQueue workQueue, 
RejectedExecutionHandler handler) 
corePoolSize: 線程池維護線程的最少數量 
maximumPoolSize:線程池維護線程的最大數量 
keepAliveTime: 線程池維護線程所容許的空閒時間 
unit: 線程池維護線程所容許的空閒時間的單位 
workQueue: 線程池所使用的緩衝隊列 
handler: 線程池對拒絕任務的處理策略 

一個任務經過 execute(Runnable)方法被添加到線程池,任務就是一個 Runnable類型的對象,任務的執行方法就是 Runnable類型對象的run()方法。 

當一個任務經過execute(Runnable)方法欲添加到線程池時: 

若是此時線程池中的數量小於corePoolSize,即便線程池中的線程都處於空閒狀態,也要建立新的線程來處理被添加的任務。 
若是此時線程池中的數量等於 corePoolSize,可是緩衝隊列 workQueue未滿,那麼任務被放入緩衝隊列。 
若是此時線程池中的數量大於corePoolSize,緩衝隊列workQueue滿,而且線程池中的數量小於maximumPoolSize,建新的線程來處理被添加的任務。 
若是此時線程池中的數量大於corePoolSize,緩衝隊列workQueue滿,而且線程池中的數量等於maximumPoolSize,那麼經過 handler所指定的策略來處理此任務。 

也就是:處理任務的優先級爲: 
核心線程corePoolSize、任務隊列workQueue、最大線程maximumPoolSize,若是三者都滿了,使用handler處理被拒絕的任務。 

當線程池中的線程數量大於 corePoolSize時,若是某線程空閒時間超過keepAliveTime,線程將被終止。這樣,線程池能夠動態的調整池中的線程數。 

unit可選的參數爲java.util.concurrent.TimeUnit中的幾個靜態屬性: 
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。 

workQueue我經常使用的是:java.util.concurrent.ArrayBlockingQueue 

handler有四個選擇: 
ThreadPoolExecutor.AbortPolicy() 
拋出java.util.concurrent.RejectedExecutionException異常 
ThreadPoolExecutor.CallerRunsPolicy() 
重試添加當前的任務,他會自動重複調用execute()方法 
ThreadPoolExecutor.DiscardOldestPolicy() 
拋棄舊的任務 
ThreadPoolExecutor.DiscardPolicy() 
拋棄當前的任務 

2、通常用法舉例 

點擊(此處)摺疊或打開 java

  1. package demo;

  2. import java.io.Serializable;
  3. import java.util.concurrent.ArrayBlockingQueue;
  4. import java.util.concurrent.ThreadPoolExecutor;
  5. import java.util.concurrent.TimeUnit;

  6. public class TestThreadPool2
  7. {
  8.     private static int produceTaskSleepTime = 2;
  9.     private static int produceTaskMaxNumber = 10;

  10.     public static void main(String[] args)
  11.     {
  12.         // 構造一個線程池
  13.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
  14.                 new ThreadPoolExecutor.DiscardOldestPolicy());

  15.         for (int i = 1; i <= produceTaskMaxNumber; i++)
  16.         {
  17.             try
  18.             {
  19.                 // 產生一個任務,並將其加入到線程池
  20.                 String task = "task@ " + i;
  21.                 System.out.println("put " + task);
  22.                 threadPool.execute(new ThreadPoolTask(task));

  23.                 // 便於觀察,等待一段時間
  24.                 Thread.sleep(produceTaskSleepTime);
  25.             }
  26.             catch (Exception e)
  27.             {
  28.                 e.printStackTrace();
  29.             }
  30.         }
  31.     }
  32. }

  33. /**
  34.  * 線程池執行的任務
  35.  */
  36. class ThreadPoolTask implements Runnable, Serializable
  37. {
  38.     private static final long serialVersionUID = 0;
  39.     private static int consumeTaskSleepTime = 2000;
  40.     // 保存任務所須要的數據
  41.     private Object threadPoolTaskData;

  42.     ThreadPoolTask(Object tasks)
  43.     {
  44.         this.threadPoolTaskData = tasks;
  45.     }

  46.     public void run()
  47.     {
  48.         // 處理一個任務,這裏的處理方式太簡單了,僅僅是一個打印語句
  49.         System.out.println(Thread.currentThread().getName());
  50.         System.out.println("start .." + threadPoolTaskData);

  51.         try
  52.         {
  53.             // //便於觀察,等待一段時間
  54.             Thread.sleep(consumeTaskSleepTime);
  55.         }
  56.         catch (Exception e)
  57.         {
  58.             e.printStackTrace();
  59.         }
  60.         threadPoolTaskData = null;
  61.     }

  62.     public Object getTask()
  63.     {
  64.         return this.threadPoolTaskData;
  65.     }
  66. }
說明: 
一、在這段程序中,一個任務就是一個Runnable類型的對象,也就是一個ThreadPoolTask類型的對象。 
二、通常來講任務除了處理方式外,還須要處理的數據,處理的數據經過構造方法傳給任務。 
三、在這段程序中,main()方法至關於一個殘忍的領導,他派發出許多任務,丟給一個叫 threadPool的不辭辛苦的小組來作。 
這個小組裏面隊員至少有兩個,若是他們兩個忙不過來,任務就被放到任務列表裏面。 
若是積壓的任務過多,多到任務列表都裝不下(超過3個)的時候,就僱傭新的隊員來幫忙。可是基於成本的考慮,不能僱傭太多的隊員,至多隻能僱傭 4個。 
若是四個隊員都在忙時,再有新的任務,這個小組就處理不了了,任務就會被經過一種策略來處理,咱們的處理方式是不停的派發,直到接受這個任務爲止(更殘忍!呵呵)。 
由於隊員工做是須要成本的,若是工做很閒,閒到 3SECONDS都沒有新的任務了,那麼有的隊員就會被解僱了,可是,爲了小組的正常運轉,即便工做再閒,小組的隊員也不能少於兩個。 
四、經過調整 produceTaskSleepTime和 consumeTaskSleepTime的大小來實現對派發任務和處理任務的速度的控制,改變這兩個值就能夠觀察不一樣速率下程序的工做狀況。 
五、經過調整4中所指的數據,再加上調整任務丟棄策略,換上其餘三種策略,就能夠看出不一樣策略下的不一樣處理方式。 
六、對於其餘的使用方法,參看jdk的幫助,很容易理解和使用。 


另外一個例子: 

點擊(此處)摺疊或打開 this

  1. package demo;

  2. import java.util.Queue;
  3. import java.util.concurrent.ArrayBlockingQueue;
  4. import java.util.concurrent.ThreadPoolExecutor;
  5. import java.util.concurrent.TimeUnit;

  6. public class ThreadPoolExecutorTest
  7. {

  8.     private static int queueDeep = 4;

  9.     public void createThreadPool()
  10.     {
  11.         /* 
  12.          * 建立線程池,最小線程數爲2,最大線程數爲4,線程池維護線程的空閒時間爲3秒, 
  13.          * 使用隊列深度爲4的有界隊列,若是執行程序還沒有關閉,則位於工做隊列頭部的任務將被刪除, 
  14.          * 而後重試執行程序(若是再次失敗,則重複此過程),裏面已經根據隊列深度對任務加載進行了控制。 
  15.          */ 
  16.         ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueDeep),
  17.                 new ThreadPoolExecutor.DiscardOldestPolicy());

  18.         // 向線程池中添加 10 個任務
  19.         for (int i = 0; i < 10; i++)
  20.         {
  21.             try
  22.             {
  23.                 Thread.sleep(1);
  24.             }
  25.             catch (InterruptedException e)
  26.             {
  27.                 e.printStackTrace();
  28.             }
  29.             while (getQueueSize(tpe.getQueue()) >= queueDeep)
  30.             {
  31.                 System.out.println("隊列已滿,等3秒再添加任務");
  32.                 try
  33.                 {
  34.                     Thread.sleep(3000);
  35.                 }
  36.                 catch (InterruptedException e)
  37.                 {
  38.                     e.printStackTrace();
  39.                 }
  40.             }
  41.             TaskThreadPool ttp = new TaskThreadPool(i);
  42.             System.out.println("put i:" + i);
  43.             tpe.execute(ttp);
  44.         }

  45.         tpe.shutdown();
  46.     }

  47.     private synchronized int getQueueSize(Queue queue)
  48.     {
  49.         return queue.size();
  50.     }

  51.     public static void main(String[] args)
  52.     {
  53.         ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
  54.         test.createThreadPool();
  55.     }

  56.     class TaskThreadPool implements Runnable
  57.     {
  58.         private int index;

  59.         public TaskThreadPool(int index)
  60.         {
  61.             this.index = index;
  62.         }

  63.         public void run()
  64.         {
  65.             System.out.println(Thread.currentThread() + " index:" + index);
  66.             try
  67.             {
  68.                 Thread.sleep(3000);
  69.             }
  70.             catch (InterruptedException e)
  71.             {
  72.                 e.printStackTrace();
  73.             }
  74.         }
  75.     }
  76. }
相關文章
相關標籤/搜索