1. 程式人生 > >java和spring 線程池總結

java和spring 線程池總結

一段 getname span 只有一個 [] 觸發 sts time execute

1. spring 的線程池 ThreadPoolTaskExecutor

@Configuration
public class ThreadPoolConfig {
    @Bean("threadPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor(){
        ThreadPoolTaskExecutor threadPoolTaskExecutor=new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(
4); threadPoolTaskExecutor.setKeepAliveSeconds(10); threadPoolTaskExecutor.setMaxPoolSize(10); threadPoolTaskExecutor.setQueueCapacity(10); return threadPoolTaskExecutor; } }

2. jdk1.7自己帶的線程池

    private ThreadPoolExecutor scheduleExecutor =
            new
ThreadPoolExecutor(100, 100, 0, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(100), new NamedThreadFactory("basic-data"), new LoggerDiscardPolicy());

3. 線程池不允許使用 Executors 去創建,而是通過 ThreadPoolExecutor 的方式,這樣 的處理方式讓寫的同學更加明確線程池的運行規則,規避資源耗盡的風險。 說明:Executors 返回的線程池對象的弊端如下:

1)FixedThreadPool 和 SingleThreadPool: 允許的請求隊列長度為 Integer.MAX_VALUE,可能會堆積大量的請求,從而導致 OOM。2)CachedThreadPool 和 ScheduledThreadPool:允許的創建線程數量為 Integer.MAX_VALUE,可能會創建大量的線程,從而導致 OOM。

 

<http://blog.csdn.net/sd0902/article/details/8395677>

Java線程池使用說明

一簡介

線程的使用在java中占有極其重要的地位,在jdk1.4極其之前的jdk版本中,關於線程池的使用是極其簡陋的。在jdk1.5之後這一情況有了很大的改觀。Jdk1.5之後加入了java.util.concurrent包,這個包中主要介紹java中線程以及線程池的使用。為我們在開發中處理線程的問題提供了非常大的幫助。

二:線程池

線程池的作用:

線程池作用就是限制系統中執行線程的數量。
根據系統的環境情況,可以自動或手動設置線程數量,達到運行的最佳效果;少了浪費了系統資源,多了造成系統擁擠效率不高。用線程池控制線程數量,其他線程排隊等候。一個任務執行完畢,再從隊列的中取最前面的任務開始執行。若隊列中沒有等待進程,線程池的這一資源處於等待。當一個新任務需要運行時,如果線程池中有等待的工作線程,就可以開始運行了;否則進入等待隊列。

為什麽要用線程池:

1.減少了創建和銷毀線程的次數,每個工作線程都可以被重復利用,可執行多個任務。

2.可以根據系統的承受能力,調整線程池中工作線線程的數目,防止因為消耗過多的內存,而把服務器累趴下(每個線程需要大約1MB內存,線程開的越多,消耗的內存也就越大,最後死機)。

Java裏面線程池的頂級接口是Executor,但是嚴格意義上講Executor並不是一個線程池,而只是一個執行線程的工具。真正的線程池接口是ExecutorService。

比較重要的幾個類:

ExecutorService

真正的線程池接口。

ScheduledExecutorService

能和Timer/TimerTask類似,解決那些需要任務重復執行的問題。

ThreadPoolExecutor

ExecutorService的默認實現。

ScheduledThreadPoolExecutor

繼承ThreadPoolExecutor的ScheduledExecutorService接口實現,周期性任務調度的類實現。

要配置一個線程池是比較復雜的,尤其是對於線程池的原理不是很清楚的情況下,很有可能配置的線程池不是較優的,因此在Executors類裏面提供了一些靜態工廠,生成一些常用的線程池。

1. newSingleThreadExecutor

創建一個單線程的線程池。這個線程池只有一個線程在工作,也就是相當於單線程串行執行所有任務。如果這個唯一的線程因為異常結束,那麽會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。

2.newFixedThreadPool

創建固定大小的線程池。每次提交一個任務就創建一個線程,直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變,如果某個線程因為執行異常而結束,那麽線程池會補充一個新線程。

3. newCachedThreadPool

創建一個可緩存的線程池。如果線程池的大小超過了處理任務所需要的線程,

那麽就會回收部分空閑(60秒不執行任務)的線程,當任務數增加時,此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制,線程池大小完全依賴於操作系統(或者說JVM)能夠創建的最大線程大小。

4.newScheduledThreadPool

創建一個大小無限的線程池。此線程池支持定時以及周期性執行任務的需求。

實例

1:newSingleThreadExecutor

MyThread.java

publicclassMyThread extends Thread {

@Override

publicvoid run() {

System.out.println(Thread.currentThread().getName() + "正在執行。。。");

}

}

TestSingleThreadExecutor.java

publicclassTestSingleThreadExecutor {

publicstaticvoid main(String[] args) {

//創建一個可重用固定線程數的線程池

ExecutorService pool = Executors. newSingleThreadExecutor();

//創建實現了Runnable接口對象,Thread對象當然也實現了Runnable接口

Thread t1 = new MyThread();

Thread t2 = new MyThread();

Thread t3 = new MyThread();

Thread t4 = new MyThread();

Thread t5 = new MyThread();

//將線程放入池中進行執行

pool.execute(t1);

pool.execute(t2);

pool.execute(t3);

pool.execute(t4);

pool.execute(t5);

//關閉線程池

pool.shutdown();

}

}

輸出結果

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

2newFixedThreadPool

TestFixedThreadPool.Java

publicclass TestFixedThreadPool {

publicstaticvoid main(String[] args) {

//創建一個可重用固定線程數的線程池

ExecutorService pool = Executors.newFixedThreadPool(2);

//創建實現了Runnable接口對象,Thread對象當然也實現了Runnable接口

Thread t1 = new MyThread();

Thread t2 = new MyThread();

Thread t3 = new MyThread();

Thread t4 = new MyThread();

Thread t5 = new MyThread();

//將線程放入池中進行執行

pool.execute(t1);

pool.execute(t2);

pool.execute(t3);

pool.execute(t4);

pool.execute(t5);

//關閉線程池

pool.shutdown();

}

}

輸出結果

pool-1-thread-1正在執行。。。

pool-1-thread-2正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-2正在執行。。。

pool-1-thread-1正在執行。。。

3 newCachedThreadPool

TestCachedThreadPool.java

publicclass TestCachedThreadPool {

publicstaticvoid main(String[] args) {

//創建一個可重用固定線程數的線程池

ExecutorService pool = Executors.newCachedThreadPool();

//創建實現了Runnable接口對象,Thread對象當然也實現了Runnable接口

Thread t1 = new MyThread();

Thread t2 = new MyThread();

Thread t3 = new MyThread();

Thread t4 = new MyThread();

Thread t5 = new MyThread();

//將線程放入池中進行執行

pool.execute(t1);

pool.execute(t2);

pool.execute(t3);

pool.execute(t4);

pool.execute(t5);

//關閉線程池

pool.shutdown();

}

}

輸出結果:

pool-1-thread-2正在執行。。。

pool-1-thread-4正在執行。。。

pool-1-thread-3正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-5正在執行。。。

4newScheduledThreadPool

TestScheduledThreadPoolExecutor.java

publicclass TestScheduledThreadPoolExecutor {

publicstaticvoid main(String[] args) {

ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);

exec.scheduleAtFixedRate(new Runnable() {//每隔一段時間就觸發異常

@Override

publicvoid run() {

//throw new RuntimeException();

System.out.println("================");

}

}, 1000, 5000, TimeUnit.MILLISECONDS);

exec.scheduleAtFixedRate(new Runnable() {//每隔一段時間打印系統時間,證明兩者是互不影響的

@Override

publicvoid run() {

System.out.println(System.nanoTime());

}

}, 1000, 2000, TimeUnit.MILLISECONDS);

}

}

輸出結果

================

8384644549516

8386643829034

8388643830710

================

8390643851383

8392643879319

8400643939383

三:ThreadPoolExecutor詳解

ThreadPoolExecutor的完整構造方法的簽名是:ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) .

corePoolSize - 池中所保存的線程數,包括空閑線程。

maximumPoolSize-池中允許的最大線程數。

keepAliveTime - 當線程數大於核心時,此為終止前多余的空閑線程等待新任務的最長時間。

unit - keepAliveTime 參數的時間單位。

workQueue - 執行前用於保持任務的隊列。此隊列僅保持由 execute方法提交的 Runnable任務。

threadFactory - 執行程序創建新線程時使用的工廠。

handler - 由於超出線程範圍和隊列容量而使執行被阻塞時所使用的處理程序。

ThreadPoolExecutor是Executors類的底層實現。

在JDK幫助文檔中,有如此一段話:

“強烈建議程序員使用較為方便的Executors工廠方法Executors.newCachedThreadPool()(無界線程池,可以進行自動線程回收)、Executors.newFixedThreadPool(int)(固定大小線程池)Executors.newSingleThreadExecutor()(單個後臺線程)

它們均為大多數使用場景預定義了設置。”

下面介紹一下幾個類的源碼:

ExecutorService newFixedThreadPool (int nThreads):固定大小線程池。

可以看到,corePoolSize和maximumPoolSize的大小是一樣的(實際上,後面會介紹,如果使用無界queue的話maximumPoolSize參數是沒有意義的),keepAliveTime和unit的設值表名什麽?-就是該實現不想keep alive!最後的BlockingQueue選擇了LinkedBlockingQueue,該queue有一個特點,他是無界的。

1. public static ExecutorService newFixedThreadPool(int nThreads) {

2. return new ThreadPoolExecutor(nThreads, nThreads,

3. 0L, TimeUnit.MILLISECONDS,

4. new LinkedBlockingQueue<Runnable>());

5. }

ExecutorService newSingleThreadExecutor():單線程

1. public static ExecutorService newSingleThreadExecutor() {

2. return new FinalizableDelegatedExecutorService

3. (new ThreadPoolExecutor(1, 1,

4. 0L, TimeUnit.MILLISECONDS,

5. new LinkedBlockingQueue<Runnable>()));

6. }

ExecutorService newCachedThreadPool():無界線程池,可以進行自動線程回收

這個實現就有意思了。首先是無界的線程池,所以我們可以發現maximumPoolSize為big big。其次BlockingQueue的選擇上使用SynchronousQueue。可能對於該BlockingQueue有些陌生,簡單說:該QUEUE中,每個插入操作必須等待另一個線程的對應移除操作。

1. public static ExecutorService newCachedThreadPool() {

2. return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

3. 60L, TimeUnit.SECONDS,

4. new SynchronousQueue<Runnable>());

  1. }

先從BlockingQueue<Runnable> workQueue這個入參開始說起。在JDK中,其實已經說得很清楚了,一共有三種類型的queue。

所有BlockingQueue 都可用於傳輸和保持提交的任務。可以使用此隊列與池大小進行交互:

如果運行的線程少於 corePoolSize,則 Executor始終首選添加新的線程,而不進行排隊。(如果當前運行的線程小於corePoolSize,則任務根本不會存放,添加到queue中,而是直接抄家夥(thread)開始運行)

如果運行的線程等於或多於 corePoolSize,則 Executor始終首選將請求加入隊列,而不添加新的線程

如果無法將請求加入隊列,則創建新的線程,除非創建此線程超出 maximumPoolSize,在這種情況下,任務將被拒絕。

queue上的三種類型。

排隊有三種通用策略:

直接提交。工作隊列的默認選項是 SynchronousQueue,它將任務直接提交給線程而不保持它們。在此,如果不存在可用於立即運行任務的線程,則試圖把任務加入隊列將失敗,因此會構造一個新的線程。此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。直接提交通常要求無界maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過隊列所能處理的平均數連續到達時,此策略允許無界線程具有增長的可能性。

無界隊列。使用無界隊列(例如,不具有預定義容量的 LinkedBlockingQueue)將導致在所有 corePoolSize 線程都忙時新任務在隊列中等待。這樣,創建的線程就不會超過 corePoolSize。(因此,maximumPoolSize的值也就無效了。)當每個任務完全獨立於其他任務,即任務執行互不影響時,適合於使用無界隊列;例如,在 Web頁服務器中。這種排隊可用於處理瞬態突發請求,當命令以超過隊列所能處理的平均數連續到達時,此策略允許無界線程具有增長的可能性。

有界隊列。當使用有限的 maximumPoolSizes時,有界隊列(如 ArrayBlockingQueue)有助於防止資源耗盡,但是可能較難調整和控制。隊列大小和最大池大小可能需要相互折衷:使用大型隊列和小型池可以最大限度地降低 CPU 使用率、操作系統資源和上下文切換開銷,但是可能導致人工降低吞吐量。如果任務頻繁阻塞(例如,如果它們是 I/O邊界),則系統可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小,CPU使用率較高,但是可能遇到不可接受的調度開銷,這樣也會降低吞吐量。

BlockingQueue的選擇。

例子一:使用直接提交策略,也即SynchronousQueue。

首先SynchronousQueue是無界的,也就是說他存數任務的能力是沒有限制的,但是由於該Queue本身的特性,在某次添加元素後必須等待其他線程取走後才能繼續添加。在這裏不是核心線程便是新創建的線程,但是我們試想一樣下,下面的場景。

我們使用一下參數構造ThreadPoolExecutor:

1. new ThreadPoolExecutor(

2. 2, 3, 30, TimeUnit.SECONDS,

3. new SynchronousQueue<Runnable>(),

4. new RecorderThreadFactory("CookieRecorderPool"),

  1. new ThreadPoolExecutor.CallerRunsPolicy());

new ThreadPoolExecutor(

2, 3, 30, TimeUnit.SECONDS,

new SynchronousQueue<Runnable>(),

new RecorderThreadFactory("CookieRecorderPool"),

new ThreadPoolExecutor.CallerRunsPolicy());

當核心線程已經有2個正在運行.

  1. 此時繼續來了一個任務(A),根據前面介紹的“如果運行的線程等於或多於 corePoolSize,則 Executor始終首選將請求加入隊列,而不添加新的線程。”,所以A被添加到queue中。
  2. 又來了一個任務(B),且核心2個線程還沒有忙完,OK,接下來首先嘗試1中描述,但是由於使用的SynchronousQueue,所以一定無法加入進去。
  3. 此時便滿足了上面提到的“如果無法將請求加入隊列,則創建新的線程,除非創建此線程超出maximumPoolSize,在這種情況下,任務將被拒絕。”,所以必然會新建一個線程來運行這個任務。
  4. 暫時還可以,但是如果這三個任務都還沒完成,連續來了兩個任務,第一個添加入queue中,後一個呢?queue中無法插入,而線程數達到了maximumPoolSize,所以只好執行異常策略了。

所以在使用SynchronousQueue通常要求maximumPoolSize是無界的,這樣就可以避免上述情況發生(如果希望限制就直接使用有界隊列)。對於使用SynchronousQueue的作用jdk中寫的很清楚:此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。

什麽意思?如果你的任務A1,A2有內部關聯,A1需要先運行,那麽先提交A1,再提交A2,當使用SynchronousQueue我們可以保證,A1必定先被執行,在A1麽有被執行前,A2不可能添加入queue中。

例子二:使用無界隊列策略,即LinkedBlockingQueue

這個就拿newFixedThreadPool來說,根據前文提到的規則:

如果運行的線程少於 corePoolSize,則 Executor 始終首選添加新的線程,而不進行排隊。那麽當任務繼續增加,會發生什麽呢?

如果運行的線程等於或多於 corePoolSize,則 Executor 始終首選將請求加入隊列,而不添加新的線程。OK,此時任務變加入隊列之中了,那什麽時候才會添加新線程呢?

如果無法將請求加入隊列,則創建新的線程,除非創建此線程超出 maximumPoolSize,在這種情況下,任務將被拒絕。這裏就很有意思了,可能會出現無法加入隊列嗎?不像SynchronousQueue那樣有其自身的特點,對於無界隊列來說,總是可以加入的(資源耗盡,當然另當別論)。換句說,永遠也不會觸發產生新的線程!corePoolSize大小的線程數會一直運行,忙完當前的,就從隊列中拿任務開始運行。所以要防止任務瘋長,比如任務運行的實行比較長,而添加任務的速度遠遠超過處理任務的時間,而且還不斷增加,不一會兒就爆了。

例子三:有界隊列,使用ArrayBlockingQueue。

這個是最為復雜的使用,所以JDK不推薦使用也有些道理。與上面的相比,最大的特點便是可以防止資源耗盡的情況發生。

舉例來說,請看如下構造方法:

1. new ThreadPoolExecutor(

2. 2, 4, 30, TimeUnit.SECONDS,

3. new ArrayBlockingQueue<Runnable>(2),

4. new RecorderThreadFactory("CookieRecorderPool"),

5. new ThreadPoolExecutor.CallerRunsPolicy());

new ThreadPoolExecutor(

2, 4, 30, TimeUnit.SECONDS,

new ArrayBlockingQueue<Runnable>(2),

new RecorderThreadFactory("CookieRecorderPool"),

new ThreadPoolExecutor.CallerRunsPolicy());

假設,所有的任務都永遠無法執行完。

對於首先來的A,B來說直接運行,接下來,如果來了C,D,他們會被放到queue中,如果接下來再來E,F,則增加線程運行E,F。但是如果再來任務,隊列無法再接受了,線程數也到達最大的限制了,所以就會使用拒絕策略來處理。

keepAliveTime

jdk中的解釋是:當線程數大於核心時,此為終止前多余的空閑線程等待新任務的最長時間。

有點拗口,其實這個不難理解,在使用了“池”的應用中,大多都有類似的參數需要配置。比如數據庫連接池,DBCP中的maxIdle,minIdle參數。

什麽意思?接著上面的解釋,後來向老板派來的工人始終是“借來的”,俗話說“有借就有還”,但這裏的問題就是什麽時候還了,如果借來的工人剛完成一個任務就還回去,後來發現任務還有,那豈不是又要去借?這一來一往,老板肯定頭也大死了。

合理的策略:既然借了,那就多借一會兒。直到“某一段”時間後,發現再也用不到這些工人時,便可以還回去了。這裏的某一段時間便是keepAliveTime的含義,TimeUnit為keepAliveTime值的度量。

RejectedExecutionHandler

另一種情況便是,即使向老板借了工人,但是任務還是繼續過來,還是忙不過來,這時整個隊伍只好拒絕接受了。

RejectedExecutionHandler接口提供了對於拒絕任務的處理的自定方法的機會。在ThreadPoolExecutor中已經默認包含了4中策略,因為源碼非常簡單,這裏直接貼出來。

CallerRunsPolicy:線程調用運行該任務的 execute 本身。此策略提供簡單的反饋控制機制,能夠減緩新任務的提交速度。

1. public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

2. if (!e.isShutdown()) {

3. r.run();

4. }

5. }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

if (!e.isShutdown()) {

r.run();

}

}

這個策略顯然不想放棄執行任務。但是由於池中已經沒有任何資源了,那麽就直接使用調用該execute的線程本身來執行。

AbortPolicy:處理程序遭到拒絕將拋出運行時RejectedExecutionException

1. public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

2. throw new RejectedExecutionException();

3. }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

throw new RejectedExecutionException();

}

這種策略直接拋出異常,丟棄任務。

DiscardPolicy:不能執行的任務將被刪除

1. public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

2. }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

}

這種策略和AbortPolicy幾乎一樣,也是丟棄任務,只不過他不拋出異常。

DiscardOldestPolicy:如果執行程序尚未關閉,則位於工作隊列頭部的任務將被刪除,然後重試執行程序(如果再次失敗,則重復此過程)

1. public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

2. if (!e.isShutdown()) {

3. e.getQueue().poll();

4. e.execute(r);

5. }

  1. }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

if (!e.isShutdown()) {

e.getQueue().poll();

e.execute(r);

}

}

該策略就稍微復雜一些,在pool沒有關閉的前提下首先丟掉緩存在隊列中的最早的任務,然後重新嘗試運行該任務。這個策略需要適當小心。

設想:如果其他線程都還在運行,那麽新來任務踢掉舊任務,緩存在queue中,再來一個任務又會踢掉queue中最老任務。

總結:

keepAliveTime和maximumPoolSize及BlockingQueue的類型均有關系。如果BlockingQueue是無界的,那麽永遠不會觸發maximumPoolSize,自然keepAliveTime也就沒有了意義。

反之,如果核心數較小,有界BlockingQueue數值又較小,同時keepAliveTime又設的很小,如果任務頻繁,那麽系統就會頻繁的申請回收線程。

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>());

}

java和spring 線程池總結