線程池的優點:
1.重用線程池中的線程,減少因對象創建,銷燬所帶來的性能開銷;
2.能有效的控制線程的最大併發數,提高系統資源利用率,同時避免過多的資源競爭,避免堵塞;
3.能夠多線程進行簡單的管理,使線程的使用簡單、高效。
線程池框架Executor
java中的線程池是通過Executor框架實現的,Executor 框架包括類:Executor,Executors,ExecutorService,ThreadPoolExecutor ,Callable和Future、FutureTask的使用等。
Executor: 所有線程池的接口,只有一個方法。
public interface Executor {
void execute(Runnable command);
}
ExecutorService: 增加Executor的行爲,是Executor實現類的最直接接口。
Executors: 提供了一系列工廠方法用於創先線程池,返回的線程池都實現了ExecutorService 接口。
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
corePoolSize:線程池的核心線程數,線程池中運行的線程數也永遠不會超過 corePoolSize 個,默認情況下可以一直存活。可以通過設置allowCoreThreadTimeOut爲True,此時 核心線程數就是0,此時keepAliveTime控制所有線程的超時時間。
maximumPoolSize:線程池允許的最大線程數;
keepAliveTime: 指的是空閒線程結束的超時時間;
unit :是一個枚舉,表示 keepAliveTime 的單位;
workQueue:表示存放任務的BlockingQueue<Runnable隊列。
BlockingQueue: 阻塞隊列(BlockingQueue)是java.util.concurrent下的主要用來控制線程同步的工具。如果BlockQueue是空的,從BlockingQueue取東西的操作將會被阻斷進入等待狀態,直到BlockingQueue進了東西纔會被喚醒。同樣,如果BlockingQueue是滿的,任何試圖往裏存東西的操作也會被阻斷進入等待狀態,直到BlockingQueue裏有空間纔會被喚醒繼續操作。 阻塞隊列常用於生產者和消費者的場景,生產者是往隊列裏添加元素的線程,消費者是從隊列裏拿元素的線程。阻塞隊列就是生產者存放元素的容器,而消費者也只從容器裏拿元素。具體的實現類有LinkedBlockingQueue,ArrayBlockingQueued等。一般其內部的都是通過Lock和Condition(顯示鎖(Lock)及Condition的學習與使用)來實現阻塞和喚醒。
線程池的工作過程如下:
線程池剛創建時,裏面沒有一個線程。任務隊列是作爲參數傳進來的。不過,就算隊列裏面有任務,線程池也不會馬上執行它們。
當調用 execute() 方法添加一個任務時,線程池會做如下判斷:
如果正在運行的線程數量小於 corePoolSize,那麼馬上創建線程運行這個任務;
如果正在運行的線程數量大於或等於 corePoolSize,那麼將這個任務放入隊列;
如果這時候隊列滿了,而且正在運行的線程數量小於 maximumPoolSize,那麼還是要創建非核心線程立刻運行這個任務;
如果隊列滿了,而且正在運行的線程數量大於或等於 maximumPoolSize,那麼線程池會拋出異常RejectExecutionException。
當一個線程完成任務時,它會從隊列中取下一個任務來執行。
當一個線程無事可做,超過一定的時間(keepAliveTime)時,線程池會判斷,如果當前運行的線程數大於 corePoolSize,那麼這個線程就被停掉。所以線程池的所有任務完成後,它最終會收縮到 corePoolSize 的大小。
線程池的創建和使用
生成線程池採用了工具類Executors的靜態方法,以下是幾種常見的線程池。
SingleThreadExecutor:單個後臺線程 (其緩衝隊列是無界的)
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService (
new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
創建一個單線程的線程池。這個線程池只有一個核心線程在工作,也就是相當於單線程串行執行所有任務。如果這個唯一的線程因爲異常結束,那麼會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。
FixedThreadPool:只有核心線程的線程池,大小固定 (其緩衝隊列是無界的) 。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
創建固定大小的線程池。每次提交一個任務就創建一個線程,直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變,如果某個線程因爲執行異常而結束,那麼線程池會補充一個新線程。
CachedThreadPool:無界線程池,可以進行自動線程回收。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0,Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
如果線程池的大小超過了處理任務所需要的線程,那麼就會回收部分空閒(60秒不執行任務)的線程,當任務數增加時,此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制,線程池大小完全依賴於操作系統(或者說JVM)能夠創建的最大線程大小。SynchronousQueue是一個是緩衝區爲1的阻塞隊列。
ScheduledThreadPool:核心線程池固定,大小無限的線程池。此線程池支持定時以及週期性執行任務的需求。
public static ExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPool(corePoolSize,
Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}
創建一個週期性執行任務的線程池。如果閒置,非核心線程池會在DEFAULT_KEEPALIVEMILLIS時間內回收。
線程池最常用的提交任務的方法有兩種:
execute:
ExecutorService.execute(Runnable runable);
submit:
FutureTask task = ExecutorService.submit(Runnable runnable);
FutureTask<T> task = ExecutorService.submit(Runnable runnable,T Result);
FutureTask<T> task = ExecutorService.submit(Callable<T> callable);
submit(Callable callable)的實現,submit(Runnable runnable)同理。
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
FutureTask<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
可以看出submit開啓的是有返回結果的任務,會返回一個FutureTask對象,這樣就能通過get()方法得到結果。submit最終調用的也是execute(Runnable runable),submit只是將Callable對象或Runnable封裝成一個FutureTask對象,因爲FutureTask是個Runnable,所以可以在execute中執行。關於Callable對象和Runnable怎麼封裝成FutureTask對象,見Callable和Future、FutureTask的使用。
線程池實現的原理
如果只講線程池的使用,那這篇博客沒有什麼大的價值,充其量也就是熟悉Executor相關API的過程。線程池的實現過程沒有用到Synchronized關鍵字,用的都是Volatile,Lock和同步(阻塞)隊列,Atomic相關類,FutureTask等等,因爲後者的性能更優。理解的過程可以很好的學習源碼中併發控制的思想。
在開篇提到過線程池的優點是可總結爲以下三點:
線程複用
控制最大併發數
管理線程
1.線程複用過程
理解線程複用原理首先應瞭解線程生命週期。
在線程的生命週期中,它要經過新建(New)、就緒(Runnable)、運行(Running)、阻塞(Blocked)和死亡(Dead)5種狀態。
Thread通過new來新建一個線程,這個過程是是初始化一些線程信息,如線程名,id,線程所屬group等,可以認爲只是個普通的對象。調用Thread的start()後Java虛擬機會爲其創建方法調用棧和程序計數器,同時將hasBeenStarted爲true,之後調用start方法就會有異常。
處於這個狀態中的線程並沒有開始運行,只是表示該線程可以運行了。至於該線程何時開始運行,取決於JVM裏線程調度器的調度。當線程獲取cpu後,run()方法會被調用。不要自己去調用Thread的run()方法。之後根據CPU的調度在就緒——運行——阻塞間切換,直到run()方法結束或其他方式停止線程,進入dead狀態。
所以實現線程複用的原理應該就是要保持線程處於存活狀態(就緒,運行或阻塞)。接下來來看下ThreadPoolExecutor是怎麼實現線程複用的。
在ThreadPoolExecutor主要Worker類來控制線程的複用。看下Worker類簡化後的代碼,這樣方便理解:
private final class Worker implements Runnable {
final Thread thread;
Runnable firstTask;
Worker(Runnable firstTask) {
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
final void runWorker(Worker w) {
Runnable task = w.firstTask;
w.firstTask = null;
while (task != null || (task = getTask()) != null){
task.run();
}
}
Worker是一個Runnable,同時擁有一個thread,這個thread就是要開啓的線程,在新建Worker對象時同時新建一個Thread對象,同時將Worker自己作爲參數傳入TThread,這樣當Thread的start()方法調用時,運行的實際上是Worker的run()方法,接着到runWorker()中,有個while循環,一直從getTask()裏得到Runnable對象,順序執行。getTask()又是怎麼得到Runnable對象的呢?
private Runnable getTask() {
if(一些特殊情況) {
return null;
}
Runnable r = workQueue.take();
return r;
}
這個workQueue就是初始化ThreadPoolExecutor時存放任務的BlockingQueue隊列,這個隊列裏的存放的都是將要執行的Runnable任務。因爲BlockingQueue是個阻塞隊列,BlockingQueue.take()得到如果是空,則進入等待狀態直到BlockingQueue有新的對象被加入時喚醒阻塞的線程。所以一般情況Thread的run()方法就不會結束,而是不斷執行從workQueue裏的Runnable任務,這就達到了線程複用的原理了。
2.控制最大併發數
那Runnable是什麼時候放入workQueue?Worker又是什麼時候創建,Worker裏的Thread的又是什麼時候調用start()開啓新線程來執行Worker的run()方法的呢?有上面的分析看出Worker裏的runWorker()執行任務時是一個接一個,串行進行的,那併發是怎麼體現的呢?
很容易想到是在execute(Runnable runnable)時會做上面的一些任務。看下execute裏是怎麼做的.
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 當前線程數 < corePoolSize
if (workerCountOf(c) < corePoolSize) {
// 直接啓動新的線程。
if (addWorker(command, true))
return;
c = ctl.get();
}
// 活動線程數 >= corePoolSize
// runState爲RUNNING && 隊列未滿
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 再次檢驗是否爲RUNNING狀態
// 非RUNNING狀態 則從workQueue中移除任務並拒絕
if (!isRunning(recheck) && remove(command))
reject(command);// 採用線程池指定的策略拒絕任務
// 兩種情況:
// 1.非RUNNING狀態拒絕新的任務
// 2.隊列滿了啓動新的線程失敗(workCount > maximumPoolSize)
} else if (!addWorker(command, false))
reject(command);
}
private boolean addWorker(Runnable firstTask, boolean core) {
int wc = workerCountOf(c);
if (wc >= (core ? corePoolSize : maximumPoolSize)) {
return false;
}
w = new Worker(firstTask);
final Thread t = w.thread;
t.start();
}
根據代碼再來看上面提到的線程池工作過程中的添加任務的情況:
如果正在運行的線程數量小於 corePoolSize,那麼馬上創建線程運行這個任務;
如果正在運行的線程數量大於或等於 corePoolSize,那麼將這個任務放入隊列;
如果這時候隊列滿了,而且正在運行的線程數量小於 maximumPoolSize,那麼還是要創建非核心線程立刻運行這個任務;
如果隊列滿了,而且正在運行的線程數量大於或等於 maximumPoolSize,那麼線程池會拋出異常RejectExecutionException。
通過addWorker如果成功創建新的線程成功,則通過start()開啓新線程,同時將firstTask作爲這個Worker裏的run()中執行的第一個任務。
雖然每個Worker的任務是串行處理,但如果創建了多個Worker,因爲共用一個workQueue,所以就會並行處理了。
所以根據corePoolSize和maximumPoolSize來控制最大併發數。
3.管理線程
通過線程池可以很好的管理線程的複用,控制併發數,以及銷燬等過程,線程的複用和控制併發上面已經講了,而線程的管理過程已經穿插在其中了,也很好理解。
在ThreadPoolExecutor有個ctl的AtomicInteger變量。通過這一個變量保存了兩個內容:
所有線程的數量 每個線程所處的狀態 其中低29位存線程數,高3位存runState,通過位運算來得到不同的值。
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//得到線程的狀態
private static int runStateOf(int c) {
return c & ~CAPACITY;
}
//得到Worker的的數量
private static int workerCountOf(int c) {
return c & CAPACITY;
}
// 判斷線程是否在運行
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
這裏主要通過shutdown和shutdownNow()來分析線程池的關閉過程。首先線程池有五種狀態來控制任務添加與執行。主要介紹以下三種:
RUNNING狀態:線程池正常運行,可以接受新的任務並處理隊列中的任務;
SHUTDOWN狀態:不再接受新的任務,但是會執行隊列中的任務;
STOP狀態:不再接受新任務,不處理隊列中的任務 shutdown這個方法會將runState置爲SHUTDOWN,會終止所有空閒的線程,而仍在工作的線程不受影響,所以隊列中的任務人會被執行。
shutdownNow方法將runState置爲STOP。和shutdown方法的區別,這個方法會終止所有的線程,所以隊列中的任務也不會被執行了。
總結
通過對ThreadPoolExecutor源碼的分析,從總體上了解了線程池的創建,任務的添加,執行等過程,熟悉這些過程,使用線程池就會更輕鬆了。
而從中學到的一些對併發控制,以及生產者——消費者模型任務處理的使用,對以後理解或解決其他相關問題會有很大的幫助。