一、簡介

什麼是線程池？

池的概念大家也許都有所聽聞，池就是相當于一個容器，裡面有許許多多的東西你可以即拿即用。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-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 線程池原理及使用方式一、簡介二、常用線程池介紹三、自定義線程池

一、簡介

二、常用線程池介紹

三、自定義線程池

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method