2. 程式人生 > >java 執行緒池 Executors 及 ThreadPoolExecutor

java 執行緒池 Executors 及 ThreadPoolExecutor

阿新 • • 發佈：2018-12-25

Java通過Executors提供四種執行緒池，分別為： 
newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。 
newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。 
newScheduledThreadPool 建立一個定長執行緒池，支援定時及週期性任務執行。 
newSingleThreadExecutor 建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

(1) newCachedThreadPool

 
建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。示例程式碼如下：

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   try {
    Thread.sleep(index * 1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   cachedThreadPool.execute(new Runnable() {
    public void run() {
     System.out.println(index);
    }
   });
  }
 }
}

執行緒池為無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的執行緒，而不用每次新建執行緒。 
  
(2) newFixedThreadPool 
建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。示例程式碼如下：

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
  for (int i = 0; i < 10; i++) {
   final int index = i;
   fixedThreadPool.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

  
因為執行緒池大小為3，每個任務輸出index後sleep 2秒，所以每兩秒列印3個數字。 
定長執行緒池的大小最好根據系統資源進行設定。如Runtime.getRuntime().availableProcessors()

(3)  newScheduledThreadPool 
建立一個定長執行緒池，支援定時及週期性任務執行。延遲執行示例程式碼如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

  
表示延遲3秒執行。

定期執行示例程式碼如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}

  
表示延遲1秒後每3秒執行一次。

(4) newSingleThreadExecutor 
建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。示例程式碼如下：

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

  
結果依次輸出，相當於順序執行各個任務。

你可以使用JDK自帶的監控工具來監控我們建立的執行緒數量，執行一個不終止的執行緒，建立指定量的執行緒，來觀察： 
工具目錄： C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe 
執行程式做稍微修改：

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();
  for (int i = 0; i < 100; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      while(true) {
       System.out.println(index);
       Thread.sleep(10 * 1000);
      }
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
   try {
    Thread.sleep(500);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
}
ThreadPoolExecutor機制    轉自http://825635381.iteye.com/blog/2184680
一、概述 
1、ThreadPoolExecutor作為java.util.concurrent包對外提供基礎實現，以內部執行緒池的形式對外提供管理任務執行，執行緒排程，執行緒池管理等等服務； 
2、Executors方法提供的執行緒服務，都是通過引數設定來實現不同的執行緒池機制。 
3、先來了解其執行緒池管理的機制，有助於正確使用，避免錯誤使用導致嚴重故障。同時可以根據自己的需求實現自己的執行緒池 

二、核心構造方法講解 
下面是ThreadPoolExecutor最核心的構造方法 
Java程式碼  收藏程式碼
  1. public ThreadPoolExecutor(int corePoolSize,  
  2.                               int maximumPoolSize,  
  3.                               long keepAliveTime,  
  4.                               TimeUnit unit,  
  5.                               BlockingQueue<Runnable> workQueue,  
  6.                               ThreadFactory threadFactory,  
  7.                               RejectedExecutionHandler handler) {  
  8.         if (corePoolSize < 0 ||  
  9.             maximumPoolSize <= 0 ||  
  10.             maximumPoolSize < corePoolSize ||  
  11.             keepAliveTime < 0)  
  12.             throw new IllegalArgumentException();  
  13.         if (workQueue == null || threadFactory == null || handler == null)  
  14.             throw new NullPointerException();  
  15.         this.corePoolSize = corePoolSize;  
  16.         this.maximumPoolSize = maximumPoolSize;  
  17.         this.workQueue = workQueue;  
  18.         this.keepAliveTime = unit.toNanos(keepAliveTime);  
  19.         this.threadFactory = threadFactory;  
  20.         this.handler = handler;  
  21.     }  

構造方法引數講解 
引數名 作用
corePoolSize 核心執行緒池大小
maximumPoolSize 最大執行緒池大小
keepAliveTime 執行緒池中超過corePoolSize數目的空閒執行緒最大存活時間；可以allowCoreThreadTimeOut(true)使得核心執行緒有效時間
TimeUnit keepAliveTime時間單位
workQueue 阻塞任務佇列
threadFactory 新建執行緒工廠
RejectedExecutionHandler 當提交任務數超過maxmumPoolSize+workQueue之和時，任務會交給RejectedExecutionHandler來處理


重點講解： 
其中比較容易讓人誤解的是：corePoolSize，maximumPoolSize，workQueue之間關係。 

1.當執行緒池小於corePoolSize時，新提交任務將建立一個新執行緒執行任務，即使此時執行緒池中存在空閒執行緒。 
2.當執行緒池達到corePoolSize時，新提交任務將被放入workQueue中，等待執行緒池中任務排程執行 
3.當workQueue已滿，且maximumPoolSize>corePoolSize時，新提交任務會建立新執行緒執行任務 
4.當提交任務數超過maximumPoolSize時，新提交任務由RejectedExecutionHandler處理 
5.當執行緒池中超過corePoolSize執行緒，空閒時間達到keepAliveTime時，關閉空閒執行緒 
6.當設定allowCoreThreadTimeOut(true)時，執行緒池中corePoolSize執行緒空閒時間達到keepAliveTime也將關閉 

執行緒管理機制圖示： 


三、Executors提供的執行緒池配置方案 

1、構造一個固定執行緒數目的執行緒池，配置的corePoolSize與maximumPoolSize大小相同，同時使用了一個無界LinkedBlockingQueue存放阻塞任務，因此多餘的任務將存在再阻塞佇列，不會由RejectedExecutionHandler處理 
Java程式碼  收藏程式碼
  1. public static ExecutorService newFixedThreadPool(int nThreads) {  
  2.         return new ThreadPoolExecutor(nThreads, nThreads,  
  3.                                       0L, TimeUnit.MILLISECONDS,  
  4.                                       new LinkedBlockingQueue<Runnable>());  
  5.     }  

2、構造一個緩衝功能的執行緒池，配置corePoolSize=0，maximumPoolSize=Integer.MAX_VALUE，keepAliveTime=60s,以及一個無容量的阻塞佇列 SynchronousQueue，因此任務提交之後，將會建立新的執行緒執行；執行緒空閒超過60s將會銷燬 
Java程式碼  收藏程式碼
  1. public static ExecutorService newCachedThreadPool() {  
  2.         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  
  3.                                       60L, TimeUnit.SECONDS,  
  4.                                       new SynchronousQueue<Runnable>());  
  5.     }  

3、構造一個只支援一個執行緒的執行緒池，配置corePoolSize=maximumPoolSize=1，無界阻塞佇列LinkedBlockingQueue；保證任務由一個執行緒序列執行 
Java程式碼  收藏程式碼
  1. public static ExecutorService newSingleThreadExecutor() {  
  2.         return new FinalizableDelegatedExecutorService  
  3.             (new ThreadPoolExecutor(1, 1,  
  4.                                     0L, TimeUnit.MILLISECONDS,  
  5.                                     new LinkedBlockingQueue<Runnable>()));  
  6.     }  

4、構造有定時功能的執行緒池，配置corePoolSize，無界延遲阻塞佇列DelayedWorkQueue；有意思的是：maximumPoolSize=Integer.MAX_VALUE，由於DelayedWorkQueue是無界佇列，所以這個值是沒有意義的 
Java程式碼  收藏程式碼
  1. public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {  
  2.         return new ScheduledThreadPoolExecutor(corePoolSize);  
  3.     }  
  4. public static ScheduledExecutorService newScheduledThreadPool(  
  5.             int corePoolSize, ThreadFactory threadFactory) {  
  6.         return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);  
  7.     }  
  8. public ScheduledThreadPoolExecutor(int corePoolSize,  
  9.                              ThreadFactory threadFactory) {  
  10.         super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,  
  11.               new DelayedWorkQueue(), threadFactory);  
  12.     }  


四、定製屬於自己的執行緒池 
Java程式碼  收藏程式碼
  1. import java.util.concurrent.ArrayBlockingQueue;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.RejectedExecutionHandler;  
  4. import java.util.concurrent.ThreadFactory;  
  5. import java.util.concurrent.ThreadPoolExecutor;  
  6. import java.util.concurrent.TimeUnit;  
  7. import java.util.concurrent.atomic.AtomicInteger;  
  8. public class CustomThreadPoolExecutor {  
  9.     private ThreadPoolExecutor pool = null;  
  10.     /** 
  11.      * 執行緒池初始化方法 
  12.      *  
  13.      * corePoolSize 核心執行緒池大小----10 
  14.      * maximumPoolSize 最大執行緒池大小----30 
  15.      * keepAliveTime 執行緒池中超過corePoolSize數目的空閒執行緒最大存活時間----30+單位TimeUnit 
  16.      * TimeUnit keepAliveTime時間單位----TimeUnit.MINUTES 
  17.      * workQueue 阻塞佇列----new ArrayBlockingQueue<Runnable>(10)====10容量的阻塞佇列 
  18.      * threadFactory 新建執行緒工廠----new CustomThreadFactory()====定製的執行緒工廠 
  19.      * rejectedExecutionHandler 當提交任務數超過maxmumPoolSize+workQueue之和時, 
  20.      *                          即當提交第41個任務時(前面執行緒都沒有執行完,此測試方法中用sleep(100)), 
  21.      *                                任務會交給RejectedExecutionHandler來處理 
  22.      */  
  23.     public void init() {  
  24.         pool = new ThreadPoolExecutor(  
  25.                 10,  
  26.                 30,  
  27.                 30,  
  28.                 TimeUnit.MINUTES,  
  29.                 new ArrayBlockingQueue<Runnable>(10),  
  30.                 new CustomThreadFactory(),  
  31.                 new CustomRejectedExecutionHandler());  
  32.     }  
  33.     public void destory() {  
  34.         if(pool != null) {  
  35.             pool.shutdownNow();  
  36.         }  
  37.     }  
  38.     public ExecutorService getCustomThreadPoolExecutor() {  
  39.         return this.pool;  
  40.     }  
  41.     private class CustomThreadFactory implements ThreadFactory {  
  42.         private AtomicInteger count = new AtomicInteger(0);  
  43.         @Override  
  44.         public Thread newThread(Runnable r) {  
  45.             Thread t = new Thread(r);  
  46.             String threadName = CustomThreadPoolExecutor.class.getSimpleName() + count.addAndGet(1);  
  47.             System.out.println(threadName);  
  48.             t.setName(threadName);  
  49.             return t;  
  50.         }  
  51.     }  
  52.     private class CustomRejectedExecutionHandler implements RejectedExecutionHandler {  
  53.         @Override  
  54.         public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {  
  55.             // 記錄異常  
  56.             // 報警處理等  
  57.             System.out.println("error.............");  
  58.         }  
  59.     }  
  60.     // 測試構造的執行緒池  
  61.     public static void main(String[] args) {  
  62.         CustomThreadPoolExecutor exec = new CustomThreadPoolExecutor();  
  63.         // 1.初始化  
  64.         exec.init();  
  65.         ExecutorService pool = exec.getCustomThreadPoolExecutor();  
  66.         for(int i=1; i<100; i++) {  
  67.             System.out.println("提交第" + i + "個任務!");  
  68.             pool.execute(new Runnable() {  
  69.                 @Override  
  70.                 public void run() {  
  71.                     try {  
  72.                         Thread.sleep(300);  
  73.                     } catch (InterruptedException e) {  
  74.                         e.printStackTrace();  
  75.                     }  
  76.                     System.out.println("running=====");  
  77.                 }  
  78.             });  
  79.         }  
  80.         // 2.銷燬----此處不能銷燬,因為任務沒有提交執行完,如果銷燬執行緒池,任務也就無法執行了  
  81.         // exec.destory();  
  82.         try {  
  83.             Thread.sleep(10000);  
  84.         } catch (InterruptedException e) {  
  85.             e.printStackTrace();  
  86.         }  
  87.     }  
  88. }  

方法中建立一個核心執行緒數為30個，緩衝佇列有10個的執行緒池。每個執行緒任務，執行時會先睡眠0.1秒，保證提交40個任務時沒有任務被執行完，這樣提交第41個任務是，會交給CustomRejectedExecutionHandler 類來處理。

相關推薦

java 執行緒池 Executors 及 ThreadPoolExecutor

Java通過Executors提供四種執行緒池，分別為：  newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。  newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列

Java執行緒池原理及使用

java中的執行緒池是運用場景最多的併發框架。在開發過程中，合理的使用執行緒池能夠帶來下面的一些好處： 1、降低資源的消耗。 2、提高響應速度。 3、提高執行緒的可管理型。 1.1、執行緒池ThreadPoolExecutor工作原理 講解之前，我們先看一張原理

深入理解Java執行緒池(1)：ThreadPoolExecutor整體流程梳理，建立worker相關方法

執行緒池作為一個執行緒的容器，主要的作用就是防止頻繁建立執行緒，節省時間資源和cpu資源。雖然一定程度上佔用了記憶體，但實際情況下利遠遠大於弊。 構造方法 public ThreadPoolExecutor( int corePoolSize, //核

JAVA執行緒池--Executors之什麼是執行緒池，為什麼使用執行緒池以及執行緒池的使用

1. 為什麼需要執行緒池？      多執行緒技術主要解決處理器單元內多個執行緒執行的問題，它可以顯著減少處理器單元的閒置時間，增加處理器單元的吞吐能力。              假設一個伺服器完成一項任務所需時間為：T1 建立執行緒時間，T2 線上程中執行任務的時間，T

java執行緒池介紹及簡單使用舉例

多執行緒雖然能夠提升程式的效能，但其實也是一把雙刃劍。"為每一個任務分配一個執行緒"的問題在於資源管理的複雜性。當我們需要頻繁的建立多個執行緒進行耗時操作時，每次通過new Thread來建立並不是一種好的辦法。new Thread 新建和銷燬物件的效能較差，執行緒缺乏統一

Java執行緒池原理及四種執行緒池的使用

 一、執行緒池簡介：     多執行緒技術主要解決處理器單元內多個執行緒執行的問題，它可以顯著減少處理器單元的閒置時間，增加處理器單元的吞吐能力。        假設一個伺服器完成一項任務所需

Java併發（4）深入分析java執行緒池框架及實現原理（一）

先說說我個人對執行緒池的理解：執行緒池顧名思義是一個裝有很多執行緒的池子，這個池子維護著從執行緒建立到銷燬的怎個生命週期以及執行緒的分配，使用者只需要把任務提交給這個執行緒池而不用去關心執行緒池如何建立執行緒，執行緒池會自己給這些任務分配執行緒資源來完成任務。 java的E

Java執行緒池原始碼及原理

目錄 1 說明 1.1類繼承圖 2 執行緒池的狀態 3 原始碼分析 3.1完整的執行緒池構造方法 3.2 ctl 3.3 任務的執行

JUC(4)---java執行緒池原理及原始碼分析

執行緒池，既然是個池子裡面肯定就裝很多執行緒。 如果併發的請求數量非常多，但每個執行緒執行的時間很短，這樣就會頻繁的建立和銷燬 執行緒，如此一來會大大降低系統的效率。可能出現伺服器在為每個請求建立新執行緒和銷燬線 程上花費的時間和消耗的系統資源要比處理實際的使用者請求的時間和資源更多。因此Java中提供執行緒

Java執行緒池原理及分析

執行緒池是很常用的併發框架，幾乎所有需要非同步和併發處理任務的程式都可用到執行緒池。 **使用執行緒池的好處如下**： 1. 降低資源消耗：可重複利用已建立的執行緒池，降低建立和銷燬帶來的消耗； 1. 提高響應速度：任務到達時，可立即執行，無需等待執行緒建立； 1. 提高執行緒的可管理性：執行緒池可對執行緒統

java執行緒池ThreadPoolExecutor原理及使用

其構造方法為public class ThreadPoolExecutor extends AbstractExecutorService{<span style="white-space:pre"> </span><div class="li

Java執行緒池ThreadPoolExecutor詳解

  1、執行緒池的工作原理？   執行緒池剛建立時，裡面沒有一個執行緒。任務佇列是作為引數傳進來的。不過，就算佇列裡面有任務，執行緒池也不會馬上執行它們。 當呼叫 execute() 方法新增一個任務時，執行緒池會做如下判斷：

Java執行緒池之ThreadPoolExecutor原始碼分析

一、引言 Java併發工具包自帶了很多常用的執行緒池，程式可以將定義的Runnable、Callable任務提交到執行緒池當中執行，由執行緒池負責非同步執行其中的任務。 Java執行緒池框架結構圖： 其中，Executors是一個執行緒池靜態工廠類，可以呼叫其

Java執行緒池詳解及例項

前言 多執行緒的非同步執行方式，雖然能夠最大限度發揮多核計算機的計算能力，但是如果不加控制，反而會對系統造成負擔。執行緒本身也要佔用記憶體空間，大量的執行緒會佔用記憶體資源並且可能會導致Out of Memory。即便沒有這樣的情況，大量的執行緒回收也會給GC帶來很大的壓力

Java執行緒池ThreadPoolExecutor

執行緒池    ThreadPoolExecutor 執行緒池是ExecutorService的實現，可以通過Executors執行工廠構造不同型別的執行服務（執行緒池）。    ThreadPoolExecutor執行緒池使用的是阻塞佇列BlockingQueue。

java執行緒池ThreadPoolExecutor類使用詳解

在《阿里巴巴java開發手冊》中指出了執行緒資源必須通過執行緒池提供，不允許在應用中自行顯示的建立執行緒，這樣一方面是執行緒的建立更加規範，可以合理控制開闢執行緒的數量；另一方面執行緒的細節管理交給執行緒池處理，優化了資源的開銷。而執行緒池不允許使用Executors去建立，而要通過ThreadPoolExe

Java常用四大執行緒池用法以及ThreadPoolExecutor詳解

為什麼用執行緒池? 1.建立/銷燬執行緒伴隨著系統開銷，過於頻繁的建立/銷燬執行緒，會很大程度上影響處-理效率 2.執行緒併發數量過多，搶佔系統資源從而導致阻塞 3.對執行緒進行一些簡單的管理 在Java中，執行緒池的概念是Executor這個介面，具體實現為ThreadPoolE

java執行緒池ThreadPoolExecutor和阻塞佇列BlockingQueue，Executor, ExecutorService

ThreadPoolExecutor 引數最全的建構函式 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,

Java併發程式設計之深入執行緒池原理及實現

Java執行緒池在實際的應用開發中十分廣泛。雖然Java1.5之後在JUC包中提供了內建執行緒池可以拿來就用，但是這之前仍有許多老的應用和系統是需要程式設計師自己開發的。因此，基於執行緒池的需求背景、技術要求瞭解執行緒池原理和實現，一方面可以更為深刻理解Java多執行緒開發，有助於解決業務系統中因為執行緒問題

Java執行緒池ThreadPoolExecutor使用和分析(二)

   相關文章目錄：     execute()是 java.util.concurrent.Executor介面中唯一的方法，JDK註釋中的描述是“在未來的某一時刻執行命令command”，即向執行緒池中提交任務，在未來某個時刻執行，提交的任務必須實現