2. 程式人生 > 程式設計 >Java常用執行緒池原理及使用方法解析

Java常用執行緒池原理及使用方法解析

阿新 • • 發佈：2020-08-03

一、簡介

什麼是執行緒池？

池的概念大家也許都有所聽聞，池就是相當於一個容器，裡面有許許多多的東西你可以即拿即用。java中有執行緒池、連線池等等。執行緒池就是在系統啟動或者例項化池時建立一些空閒的執行緒，等待工作排程，執行完任務後，執行緒並不會立即被銷燬，而是重新處於空閒狀態，等待下一次排程。

執行緒池的工作機制？

線上程池的程式設計模式中，任務提交併不是直接提交給執行緒，而是提交給池。執行緒池在拿到任務之後，就會尋找有沒有空閒的執行緒，有則分配給空閒執行緒執行，暫時沒有則會進入等待佇列，繼續等待空閒執行緒。如果超出最大接受的工作數量，則會觸發執行緒池的拒絕策略。

為什麼使用執行緒池？

執行緒的建立與銷燬需要消耗大量資源，重複的建立與銷燬明顯不必要。而且池的好處就是響應快，需要的時候自取，就不會存在等待建立的時間。執行緒池可以很好地管理系統內部的執行緒，如數量以及排程。

二、常用執行緒池介紹

Java類ExecutorService是執行緒池的父介面，並非頂層介面。以下四種常用執行緒池的型別都可以是ExecutorService。

單一執行緒池 Executors.newSingleThreadExecutor()
內部只有唯一一個執行緒進行工作排程，可以保證任務的執行順序（FIFO,LIFO）

package com.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolTest {
	public static void main(String[] args) {
		// 建立單一執行緒池
		ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
		List<String> list = new ArrayList<String>();
		list.add("first");
		list.add("second");
		list.add("third");
		list.forEach(o -> {
			// 遍歷集合提交任務
			singleThreadExecutor.execute(new Runnable() {

				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName() + " : " + o);
					try {
						// 間隔1s
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		});
	}
}

執行結果：

pool-1-thread-1 : first

pool-1-thread-1 : second

pool-1-thread-1 : third

可快取執行緒池 Executors.newCachedThreadPool()

如果執行緒池中有可使用的執行緒，則使用，如果沒有，則在池中新建一個執行緒，可快取執行緒池中執行緒數量最大為Integer.MAX_VALUE。通常用它來執行一些執行時間短，且經常用到的任務。

package com.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolTest {
	public static void main(String[] args) {
		// 建立可快取執行緒池
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		List<String> list = new ArrayList<String>();
		list.add("first");
		list.add("second");
		list.add("third");
		list.forEach(o -> {

			try {
				// 間隔3s
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			// 遍歷集合提交任務
			cachedThreadPool.execute(new Runnable() {

				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName() + " : " + o);
					try {
						// 間隔1s
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		});
	}
}

執行結果：

pool-1-thread-1 : first

pool-1-thread-1 : second

pool-1-thread-1 : third

因為間隔時間長，下一個任務執行時，上一個任務已經完成，所以執行緒可以繼續複用，如果間隔時間調短，那麼部分執行緒將會使用新執行緒來執行。

把每個任務等待時間從3s調低至1s:

執行結果：

pool-1-thread-1 : first

pool-1-thread-2 : second

pool-1-thread-1 : third

定長執行緒池 Executors.newFixedThreadPool(int nThreads)
建立一個固定執行緒數量的執行緒池，引數手動傳入

package com.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolTest {
	public static void main(String[] args) {
		// 建立可快取執行緒池
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		List<String> list = new ArrayList<String>();
		list.add("first");
		list.add("second");
		list.add("third");
		list.add("fourth");
		list.forEach(o -> {

			try {
				// 間隔1s
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			// 遍歷集合提交任務
			fixedThreadPool.execute(new Runnable() {

				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName() + " : " + o);
					try {
						// 間隔1s
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		});
	}
}

執行結果：

pool-1-thread-1 : first

pool-1-thread-2 : second

pool-1-thread-3 : third

pool-1-thread-1 : fourth

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

package com.test;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class PoolTest {
	public static void main(String[] args) {
		// 建立定長執行緒池、支援定時、延遲、週期性執行任務
		ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
		scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + " : 1秒後每隔3秒執行一次");
			}
		},1,3,TimeUnit.SECONDS);
	}
}

執行結果：

pool-1-thread-1 : 1秒後每隔3秒執行一次

pool-1-thread-1 : 1秒後每隔3秒執行一次

pool-1-thread-2 : 1秒後每隔3秒執行一次

pool-1-thread-2 : 1秒後每隔3秒執行一次

pool-1-thread-2 : 1秒後每隔3秒執行一次

pool-1-thread-2 : 1秒後每隔3秒執行一次

pool-1-thread-2 : 1秒後每隔3秒執行一次

三、自定義執行緒池

常用建構函式：

ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue)

引數說明：

1、corePoolSize 核心執行緒數大小，當執行緒數<corePoolSize ，會建立執行緒執行runnable

2、maximumPoolSize 最大執行緒數， 當執行緒數 >= corePoolSize的時候，會把runnable放入workQueue中

3、keepAliveTime 保持存活時間，當執行緒數大於corePoolSize的空閒執行緒能保持的最大時間。

4、unit 時間單位

5、workQueue 儲存任務的阻塞佇列

6、threadFactory 建立執行緒的工廠

7、handler 拒絕策略

任務執行順序：

1、當執行緒數小於corePoolSize時，建立執行緒執行任務。

2、當執行緒數大於等於corePoolSize並且workQueue沒有滿時，放入workQueue中

3、執行緒數大於等於corePoolSize並且當workQueue滿時，新任務新建執行緒執行，執行緒總數要小於maximumPoolSize

4、當執行緒總數等於maximumPoolSize並且workQueue滿了的時候執行handler的rejectedExecution。也就是拒絕策略。

ThreadPoolExecutor預設有四個拒絕策略：

1、new ThreadPoolExecutor.AbortPolicy() 直接丟擲異常RejectedExecutionException

2、new ThreadPoolExecutor.CallerRunsPolicy() 直接呼叫run方法並且阻塞執行

3、new ThreadPoolExecutor.DiscardPolicy() 直接丟棄後來的任務

4、new ThreadPoolExecutor.DiscardOldestPolicy() 丟棄在佇列中隊首的任務

緩衝佇列BlockingQueue：

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

常用的幾種BlockingQueue：

  • ArrayBlockingQueue（int i）:規定大小的BlockingQueue，其構造必須指定大小。其所含的物件是FIFO順序排序的。
  • LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其構造時指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE來決定。其所含的物件是FIFO順序排序的。
  • PriorityBlockingQueue（）或者（int i）:類似於LinkedBlockingQueue，但是其所含物件的排序不是FIFO，而是依據物件的自然順序或者建構函式的Comparator決定。
  • SynchronizedQueue（）:特殊的BlockingQueue，對其的操作必須是放和取交替完成。
package com.test;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class PoolTest {
	public static void main(String[] args) {
		// 工作佇列
		LinkedBlockingDeque<Runnable> workQueue = new LinkedBlockingDeque<Runnable>();
		// 拒絕策略
		RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,10,20,TimeUnit.MILLISECONDS,workQueue,handler);
		threadPoolExecutor.execute(new Runnable() {

			@Override
			public void run() {
				System.out.println("自定義執行緒池");
			}
		});
	}
}

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。

相關推薦

Java常用執行緒池原理及使用方法解析

一、簡介 什麼是執行緒池？ 池的概念大家也許都有所聽聞，池就是相當於一個容器，裡面有許許多多的東西你可以即拿即用。java中有執行緒池、連線池等等。執行緒池就是在系統啟動或者例項化池時建立一些空閒的執行緒

Java多執行緒volatile原理及用法解析

首先volatile有兩大功能： 保證執行緒可見性 禁止指令重排序 1、保證執行緒可見性

Java執行緒池原理及分析

執行緒池是很常用的併發框架，幾乎所有需要非同步和併發處理任務的程式都可用到執行緒池。

執行緒池原理及C語言實現執行緒池

備註：該執行緒池原始碼參考自傳直播客培訓視訊配套資料； 原始碼：https://pan.baidu.com/s/1zWuoE3q0KT5TUjmPKTb1lw 密碼：pp42

5分鐘看懂系列：Python 執行緒池原理及實現

概述 傳統多執行緒方案會使用“即時建立， 即時銷燬”的策略。儘管與建立程序相比，建立執行緒的時間已經大大的縮短，但是如果提交給執行緒的任務是執行時間較短，而且執行次數極其頻繁，那麼伺服器將處於不停的建立

SpringBoot2執行緒池定義使用方法解析

我們都知道spring只是為我們簡單的處理執行緒池，每次用到執行緒總會new 一個新的執行緒，效率不高，所以我們需要自定義一個執行緒池。

Java執行緒池原理與原始碼詳細解讀，再也不怕面試問執行緒池了！

執行緒池 “執行緒池”，顧名思義就是一個執行緒快取，執行緒是稀缺資源，如果被無限制的建立，不僅會消耗系統資源，還會降低系統的穩定性，因此Java中提供執行緒池對執行緒進行統一分配、調優和監控。

執行緒池應用及實現原理剖析

為什麼要用執行緒池 執行緒是不是越多好？ 執行緒在Java中是一個物件， 更是作業系統的資源， 執行緒額建立和銷燬都需要時間，如果 建立時間+銷燬時間>執行任務時間 就很不合算

圖解Java執行緒池原理

什麼是執行緒池？ 為了避免頻繁重複的建立和銷燬執行緒，我們可以讓這些執行緒進行復用，線上程池中，總會有活躍的執行緒在佔用，但是執行緒池中也會存在沒有佔用的執行緒，這些執行緒處於空閒狀態，當有任務的時候會

Java多執行緒start（）方法原理解析

1、為什麼啟動執行緒不用run（）方法而是使用start（）方法 run()方法只是一個類中的普通方法，呼叫run方法跟呼叫普通方法一樣

java 執行緒池的實現方法

執行緒池有以下幾種實現方式： Executors目前提供了5種不同的執行緒池建立配置：

Java 建立執行緒的3種方法及各自的優點

1. 繼承 Thread 類，然後呼叫 start 方法。 class MyThread extends Thread { //重寫run方法，執行緒執行後，跑的就是run方法

C#執行緒委託實現原理及方法解析

很多時候寫windows程式都需要結合多執行緒，在C#中用如下得程式碼來建立並啟動一個新的執行緒。

java多執行緒：執行緒池原理、阻塞佇列

一、執行緒池定義和使用 jdk 1.5 之後就引入了執行緒池。 1.1 定義 從上面的空間切換看得出來，執行緒是稀缺資源，它的建立與銷燬是一個相對偏重且耗資源的操作，而Java執行緒依賴於核心執行緒，建立執行緒需要進

Java併發程式設計之Executor執行緒池原理與原始碼解讀

1. 執行緒 1.1 定義 程序：程序是程式的一次執行，程序是一個程式及其資料在處理機上順序執行時所發生的活動，程序是 具有獨立功能的程式在一個數據集合上運⾏的過程，它是系統進行資源分配和排程的一個獨立單位

Java執行緒池二：執行緒池原理

最近精讀Netty原始碼,讀到NioEventLoop部分的時候，發現對Java執行緒&執行緒池有些概念還有困惑， 所以深入總結一下

service 方法註釋說明_JAVA執行緒池原理原始碼解析—為什麼啟動一個執行緒池，提交一個任務後，Main方法不會退出？...

技術標籤：service 方法註釋說明 public static void main(String[] args) { ExecutorService service = Executors.newFixedThreadPool(10);

Java多執行緒優化之執行緒池的使用方法

技術標籤：開發相關技術java多執行緒併發程式設計 Java多執行緒優化之執行緒池

Python定時器執行緒池原理詳解

這篇文章主要介紹了Python定時器執行緒池原理詳解,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

C++實現執行緒池的簡單方法示例

最近自己寫了一個執行緒池。 總的來說，執行緒池就是有一個任務佇列，一個執行緒佇列，執行緒佇列不斷地去取任務佇列中的任務來執行，當任務佇列中為空時，執行緒阻塞等待新的任務新增過來。