　　好程式設計師 Java 培訓分享四種常用執行緒池介紹，希望對同學們學習Java 開發有所幫助，下面我們一起來看一下吧。

　　一. 執行緒池簡介

　　 1. 執行緒池的概念：

　　執行緒池就是首先建立一些執行緒，它們的集合稱為執行緒池。使用執行緒池可以很好地提高效能，執行緒池在系統啟動時即建立大量空閒的執行緒，程式將一個任務傳給執行緒池，執行緒池就會啟動一條執行緒來執行這個任務，執行結束以後，該執行緒並不會死亡，而是再次返回執行緒池中成為空閒狀態，等待執行下一個任務。

　　 2. 執行緒池的工作機制

　　 2.1 線上程池的程式設計模式下，任務是提交給整個執行緒池，而不是直接提交給某個執行緒，執行緒池在拿到任務後，就在內部尋找是否有空閒的執行緒，如果有，則將任務交給某個空閒的執行緒。

　　 2.2 一個執行緒同時只能執行一個任務，但可以同時向一個執行緒池提交多個任務。

　　 3. 使用執行緒池的原因：

　　多執行緒執行時間，系統不斷的啟動和關閉新執行緒，成本非常高，會過渡消耗系統資源，以及過渡切換執行緒的危險，從而可能導致系統資源的崩潰。這時，執行緒池就是最好的選擇了。

　　二. 四種常見的執行緒池詳解

　　 1. 執行緒池的返回值 ExecutorService 簡介：

　　 ExecutorService 是 Java 提供的用於管理執行緒池的類。該類的兩個作用：控制執行緒數量和重用執行緒

　　 2. 具體的 4 種常用的執行緒池實現如下：（返回值都是 ExecutorService ）

　　 2.1Executors.newCacheThreadPool() ：可快取執行緒池，先檢視池中有沒有以前建立的執行緒，如果有，就直接使用。如果沒有，就建一個新的執行緒加入池中，快取型池子通常用於執行一些生存期很短的非同步型任務

示例程式碼：

package com.study.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++) {

try {

//sleep 可明顯看到使用的是執行緒池裡面以前的執行緒，沒有建立新的執行緒

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

cachedThreadPool.execute(new Runnable() {

public void run() {

// 列印正在執行的快取執行緒資訊

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

}

});

}

輸出結果：

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

執行緒池為無限大，當執行當前任務時上一個任務已經完成，會複用執行上一個任務的執行緒，而不用每次新建執行緒

2.2Executors.newFixedThreadPool(intn) ：建立一個可重用固定個數的執行緒池，以共享的無界佇列方式來執行這些執行緒。

示例程式碼：

package com.study.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++) {

fixedThreadPool.execute(new Runnable() {

public void run() {

try {

// 列印正在執行的快取執行緒資訊

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

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

});

}

輸出結果：

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

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

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

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

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

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

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

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

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

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

因為執行緒池大小為3 ，每個任務輸出列印結果後 sleep2 秒，所以每兩秒列印 3 個結果。

定長執行緒池的大小最好根據系統資源進行設定。如Runtime.getRuntime().availableProcessors()

2.3Executors.newScheduledThreadPool(intn) ：建立一個定長執行緒池，支援定時及週期性任務執行

延遲執行示例程式碼：

package com.study.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);

// 延遲 1 秒執行

scheduledThreadPool.schedule(new Runnable() {

public void run() {

System.out.println(" 延遲 1 秒執行 ");

}

}, 1, TimeUnit.SECONDS);

}

輸出結果：

延遲1 秒執行

定期執行示例程式碼：

package com.study.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);

// 延遲 1 秒後每 3 秒執行一次

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

public void run() {

System.out.println(" 延遲 1 秒後每 3 秒執行一次 ");

}

}, 1, 3, TimeUnit.SECONDS);

}

輸出結果：

延遲1 秒後每 3 秒執行一次

.............

2.4Executors.newSingleThreadExecutor() ：建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序 (FIFO,LIFO, 優先順序 ) 執行。

示例程式碼：

package com.study.test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class TestThreadPoolExecutor {

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(Thread.currentThread().getName()+" 正在被執行 , 列印的值是 :"+index);

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

});

}

輸出結果：

pool-1-thread-1 正在被執行 , 列印的值是 :0

pool-1-thread-1 正在被執行 , 列印的值是 :1

pool-1-thread-1 正在被執行 , 列印的值是 :2

pool-1-thread-1 正在被執行 , 列印的值是 :3

pool-1-thread-1 正在被執行 , 列印的值是 :4

pool-1-thread-1 正在被執行 , 列印的值是 :5

pool-1-thread-1 正在被執行 , 列印的值是 :6

pool-1-thread-1 正在被執行 , 列印的值是 :7

pool-1-thread-1 正在被執行 , 列印的值是 :8

pool-1-thread-1 正在被執行 , 列印的值是 :9

三. 緩衝佇列 BlockingQueue 和自定義執行緒池 ThreadPoolExecutor

1. 緩衝佇列 BlockingQueue 簡介：

BlockingQueue 是雙緩衝佇列。 BlockingQueue 內部使用兩條佇列，允許兩個執行緒同時向佇列一個儲存，一個取出操作。在保證併發安全的同時，提高了佇列的存取效率。

2. 常用的幾種 BlockingQueue ：

ArrayBlockingQueue （ inti ） : 規定大小的 BlockingQueue ，其構造必須指定大小。其所含的物件是 FIFO 順序排序的。

LinkedBlockingQueue （）或者（ inti ） : 大小不固定的 BlockingQueue ，若其構造時指定大小，生成的 BlockingQueue 有大小限制，不指定大小，其大小有 Integer.MAX_VALUE 來決定。其所含的物件是 FIFO 順序排序的。

PriorityBlockingQueue （）或者（ inti ） : 類似於 LinkedBlockingQueue ，但是其所含物件的排序不是 FIFO ，而是依據物件的自然順序或者建構函式的 Comparator 決定。

SynchronizedQueue （） : 特殊的 BlockingQueue ，對其的操作必須是放和取交替完成。

3. 自定義執行緒池（ ThreadPoolExecutor 和 BlockingQueue 連用）：

自定義執行緒池，可以用ThreadPoolExecutor 類建立，它有多個構造方法來建立執行緒池。

常見的建構函式：ThreadPoolExecutor(intcorePoolSize,intmaximumPoolSize,longkeepAliveTime,TimeUnitunit,BlockingQueue<Runnable>workQueue)

示例程式碼：

package com.study.test;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

class TempThread implements Runnable {

@Override

public void run() {

// 列印正在執行的快取執行緒資訊

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

try {

// sleep 一秒保證 3 個任務在分別在 3 個執行緒上執行

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

public class TestThreadPoolExecutor {

public static void main(String[] args) {

// 建立陣列型緩衝等待佇列

BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(10);

// ThreadPoolExecutor: 建立自定義執行緒池，池中儲存的執行緒數為 3 ，允許最大的執行緒數為 6

ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 6, 50, TimeUnit.MILLISECONDS, bq);

// 建立 3 個任務

Runnable t1 = new TempThread();

Runnable t2 = new TempThread();

Runnable t3 = new TempThread();

// Runnable t4 = new TempThread();

// Runnable t5 = new TempThread();

// Runnable t6 = new TempThread();

// 3 個任務在分別在 3 個執行緒上執行

tpe.execute(t1);

tpe.execute(t2);

tpe.execute(t3);

// tpe.execute(t4);

// tpe.execute(t5);

// tpe.execute(t6);

// 關閉自定義執行緒池

tpe.shutdown();

}

輸出結果：

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

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

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

好程式設計師Java培訓分享四種常用執行緒池介紹

相關文章