java線程池實作原理的源碼分析
- WBOY轉載
- 2023-05-09 14:16:071527瀏覽
執行緒池的起源
背景： 隨著電腦硬體的升級換代，讓我們的軟體具備多執行緒執行任務的能力。當我們在進行多線程編程時，就需要創建線程，如果說程序並發很高的話，我們會創建大量的線程，而每個線程執行一個時間很短的任務就結束了，這樣頻繁創建線程，會極大的降低系統效能，增加伺服器開銷，因為建立執行緒和銷毀執行緒都需要額外的消耗。
這時我們就可以藉助池化技術，來優化這個缺陷，線程池就誕生了。
池化技術的本質是在高並發場景下，為了實現資源復用，減少資源創建銷毀等開銷，如果並發數很小沒有明顯優勢（資源一直佔用系統內存，沒有機會被使用）。
池化技術介紹： 什麼時池化技術呢？池化技術是一種編程技巧，當程序出現高並發時，能夠明顯的優化程序，降低系統頻繁創建銷毀連接等額外開銷。我們經常接觸到的池化技術有資料庫連線池、執行緒池、物件池等等。池化技術的特點是將一些高成本的資源維護在一個特定的池子（記憶體）中，規定其最小連線數、最大連線數、阻塞佇列，溢位規則等配置，方便統一管理。一般情況下也會附帶一些監控，強制回收等配套功能。
池化技術作為一種資源使用技術，典型的使用情形是：
取得資源的成本較高的時候
請求資源的頻率很高且使用資源總數較低的時候
#面對效能問題，涉及到處理時間延遲的時候
池化技術資源分類：
#系統呼叫的系統資源，如執行緒、進程、記憶體分配等
網路通訊的遠端資源, 如資料庫連線、套接字連線等
#執行緒池的定義和使用
#線程池是我們為了規避創建線程，銷毀線程額外開銷而誕生的，所以說我們定義創建好線程池之後，就不需要自己來創建線程，而是使用線程池調用執行我們的任務。下面我們一起來看看如何定義並建立線程池。
方案一：Executors（僅做了解，建議使用方案二）
建立線程池可以使用Executors，其中提供了一系列工廠方法來建立線程池，傳回的線程池都實作了ExecutorService介面。
ExecutorService 介面是Executor介面的子類別接口，使用更為廣泛，其提供了線程池生命週期管理的方法，傳回 Future 物件。
也就是說我們透過Executors建立執行緒池，得到ExecutorService，透過ExecutorService執行非同步任務（實作Runnable介面）
Executors 可以建立幾個類型的執行緒池：
#newCachedThreadPool建立一個可快取執行緒池，如果執行緒池執行緒數量過剩，會在60秒後回收多餘執行緒資源，當任務書增加，執行緒不夠用，則會新建執行緒。newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大並發數，超出的執行緒會在佇列中等待。
newScheduledThreadPool建立一個定長執行緒池，支援定時及週期性任務執行。newSingleThreadExecutor建立一個單一執行緒的執行緒池，只使用唯一的執行緒來執行任務，可以保證任務會依照提交順序來完成。
方案二：ThreadPoolExecutor
在阿里巴巴開發規範中，規定執行緒池不允許透過Executors創建，而是透過ThreadPoolExecutor創建。
好處：讓寫的同學可以更明確線程池的運作規則，並規避資源耗盡的風險。
ThreadPoolExecutor的七大參數：
(1)corePoolSize 核心執行緒數量，核心執行緒會一直保留，不會被銷毀。
(2)maximumPoolSize 最大執行緒數，當核心執行緒無法滿足任務需求時，系統就會建立新的執行緒來執行任務。
(3)keepAliveTime 存活時間，核心執行緒以外的執行緒空閒多久就會被銷毀。
(4)timeUnit 代表執行緒存活的時間單位。
(5)BlockingQueue 阻塞佇列
#如果正在執行的任務超過了最大執行緒數，可以存放在佇列中，當執行緒池中有空閒資源就可以從佇列中取出任務繼續執行。
佇列類型有以下幾種類型：LinkedBlockingQueue ArrayBlockingQueue SynchronousQueue TransferQueue。
(6)threadFactory 線程工廠，用來創建線程的，可以自訂線程，例如我們可以定義線程組名稱，在jstack問題排查時，非常有幫助。
(7)rejectedExecutionHandler 拒絕策略,
當所有執行緒（最大執行緒數）都在忙，且任務佇列處於滿任務的狀態，則會執行拒絕策略。
JDK為我們提供了四種拒絕策略，我們必須都得熟悉
#AbortPolicy: 丟棄任務，並拋出異常RejectedExecutionException。 預設
DiscardPolicy: 丟棄最新的任務，不拋例外。
DiscardOldestPolicy: 丟掉排隊時間最久的任務，也就是最舊的任務。
CallerRuns: 由呼叫者（提交非同步任務的執行緒）處理任務。
線程池的實作原理
想要實作一個執行緒池我們就需要關心ThreadPoolExecutor類，因為Executors建立執行緒池也是透過new ThreadPoolExecutor物件。
看一下ThreadPoolExecutor的類別繼承關係，可以看出為什麼透過Executors建立的執行緒池傳回結果是ExecutorService，因為ThreadPoolExecutor是ExecutorService介面的實作類別，而Executors創建線程池本質也是創建的ThreadPoolExecutor 物件。
下面我們一起看一下ThreadPoolExecutor的原始碼，首先是ThreadPoolExecutor內定義的變數，常數：
// 复合类型变量 是一个原子整数 控制状态（运行状态|线程池活跃线程数量）
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3; // 低29位
private static final int CAPACITY = (1 << COUNT_BITS) - 1; // 容量
// 运行状态存储在高位3位
private static final int RUNNING = -1 << COUNT_BITS; // 接受新任务，并处理队列任务
private static final int SHUTDOWN = 0 << COUNT_BITS; // 不接受新任务，但会处理队列任务
private static final int STOP = 1 << COUNT_BITS; // 不接受新任务，不会处理队列任务，中断正在处理的任务
private static final int TIDYING = 2 << COUNT_BITS; // 所有的任务已结束，活跃线程为0，线程过渡到TIDYING状 态，将会执行terminated()钩子方法
private static final int TERMINATED = 3 << COUNT_BITS; // terminated()方法已经完成
// 设置 ctl 参数方法
private static int runStateOf(int c) { return c & ~CAPACITY; }
private static int workerCountOf(int c) { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
/**
* 阻塞队列
*/
private final BlockingQueue<Runnable> workQueue;
/**
* Lock 锁.
*/
private final ReentrantLock mainLock = new ReentrantLock();
/**
* 工人们
*/
private final HashSet<Worker> workers = new HashSet<Worker>();
/**
* 等待条件支持等待终止
*/
private final Condition termination = mainLock.newCondition();
/**
* 最大的池大小.
*/
private int largestPoolSize;
/**
* 完成任务数
*/
private long completedTaskCount;
/**
* 线程工厂
*/
private volatile ThreadFactory threadFactory;
/**
* 拒绝策略
*/
private volatile RejectedExecutionHandler handler;
/**
* 存活时间
*/
private volatile long keepAliveTime;
/**
* 允许核心线程数
*/
private volatile boolean allowCoreThreadTimeOut;
/**
* 核心线程数
*/
private volatile int corePoolSize;
/**
* 最大线程数
*/
private volatile int maximumPoolSize;
/**
* 默认拒绝策略
*/
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
/**
* shutdown and shutdownNow权限
*/
private static final RuntimePermission shutdownPerm =
new RuntimePermission("modifyThread"); 建構器,,支援最少五種參數，最大七中參數的四種建構器：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}工人，在執行緒池中執行任務的，執行緒池就是透過這些工人進行工作的，有核心員工（核心線程）和臨時工（人手不夠的時候，臨時創建的，如果空閒時間廠，就會被裁員），
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
// 工人的本质就是个线程
final Thread thread;
// 第一件工作任务
Runnable firstTask;
volatile long completedTasks;
/**
* 构造器
*/
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** 工作 */
public void run() {
runWorker(this);
}
protected boolean isHeldExclusively() {
return getState() != 0;
}
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}核心方法，通過執行緒池執行任務（這也是執行緒池的運作原理）：
檢驗任務
取得目前執行緒池狀態
判斷上班工人數是否小於核心員工數
如果小於則招人，安排工作
#不小於則判斷等候區任務是否排滿
如果沒有排滿則任務排入等候區
如果排滿，看是否允許招人，允許招人則招臨時工
-
如果都不行，該線程池無法接收新任務，開始按老闆約定的拒絕策略，執行拒絕策略
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}submit（）方法是其抽象父類別定義的，這裡我們就可以明顯看到submit與execute的區別，透過submit調用，我們會創建RunnableFuture，並且會傳回Future，這裡我們可以將傳回值類型，告知submit方法，它就會透過泛型約束傳回值。
public abstract class AbstractExecutorService implements ExecutorService {
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
...
}addWorker()是招募人的一個方法：
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 判断状态，及任务列表
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}取得任務的方法：
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}#讓員工工作的方法，分配任務，運行任務：
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}以上是java線程池實作原理的源碼分析的詳細內容。更多資訊請關注PHP中文網其他相關文章！