思考：核心线程怎么实现不释放的？临时线程又是怎么实现释放的？
- 核心线程： while（true）逻辑： 从阻塞队列里获取任务take(),获取到就继续执行，获取不到就一直阻塞在take里。
- 临时线程：可以在blockQueue.take（timeOut）带有超时时间的获取，获取不到就退出（达到了释放）
基本认识
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
ctl高3位用来标记线程池状态，低29位来标记当前池中线程个数
//用来标记线程池状态（高3位），线程个数（低29位）
//默认是RUNNING状态，线程个数为0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//线程个数掩码位数，并不是所有平台int类型是32位，所以准确说是具体平台下Integer的二进制位数-3后的剩余位数才是线程的个数，
private static final int COUNT_BITS = Integer.SIZE - 3;
//线程最大个数(低29位)00011111111111111111111111111111
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
线程池状态
//（高3位）：11100000000000000000000000000000
private static final int RUNNING = -1 << COUNT_BITS;
//（高3位）：00000000000000000000000000000000
private static final int SHUTDOWN = 0 << COUNT_BITS;
//（高3位）：00100000000000000000000000000000
private static final int STOP = 1 << COUNT_BITS;
//（高3位）：01000000000000000000000000000000
private static final int TIDYING = 2 << COUNT_BITS;
//（高3位）：01100000000000000000000000000000
private static final int TERMINATED = 3 << COUNT_BITS;
// 获取高三位 运行状态
private static int runStateOf(int c) { return c & ~CAPACITY; }
//获取低29位 线程个数
private static int workerCountOf(int c) { return c & CAPACITY; }
//计算ctl新值，线程状态 与 线程个数
private static int ctlOf(int rs, int wc) { return rs | wc; }
**
线程池类型
1. Executors.newSingleThreadExecutor
它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
2.Executors.newFixedThreadPool
**创建一个定长线程池，可控制线程最大并发数，**超出的线程会在队列中等待
3.Executors. newCachedThreadPool（唯一一个核心线程数为0的）
创建一个线程池，如果线程池中的线程数量过大，它可以有效的回收多余的线程，如果线程数不足，那么它可以创建新的线程。
- 不足：这种方式虽然可以根据业务场景自动的扩展线程数来处理我们的业务，但是最多需要多少个线程同时处理缺是我们无法控制的；
- 优点：如果当第二个任务开始，第一个任务已经执行结束，那么第二个任务会复用第一个任务创建的线程，并不会重新创建新的线程，提高了线程的复用率；
4.Executors.newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行
**
Executors.newFixedThreadPool(num)
会调用ThreadPoolExecutor构造方法只会初始化一些参数，其他什么也不干。
ExecutorService executorService = Executors.newFixedThreadPool(3);
public ThreadPoolExecutor(int corePoolSize,//核心线程数
int maximumPoolSize,//最大线程数
long keepAliveTime,//临时线程的空闲时间
TimeUnit unit,// 时间单位
BlockingQueue<Runnable> workQueue,//阻塞队列
ThreadFactory threadFactory,
RejectedExecutionHandler handler) //拒绝策略
executorService.execute（task）提交任务
execute()总结：
- 如果当前workerCount工作线程个数<核心线程个数 创建核心线程执行该任务。
- 如果当前workerCount工作线程池个数>=核心线程个数，线程池是运行状态此时将任务添加到阻塞队列（添加之后再检查线程池是否是Running状态，不是的话需要从队列里删除该任务）
- 线程池是非运行状态或阻塞队列已满等原因添加到阻塞队列失败，这时候开启新线程执行任务，开启新线程时会判断：如果此时工作线程数>=设定的最大线程个数,则会直接拒绝
public void execute(Runnable command) {
//(1) 如果任务为null，则抛出NPE异常
if (command == null)
throw new NullPointerException();
//（2）获取当前线程池的状态+线程个数变量的组合值
int c = ctl.get();
//（3）当前线程池线程个数是否小于corePoolSize,小于则开启新线程运行
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//（4）如果线程池处于RUNNING状态，则添加任务到阻塞队列
if (isRunning(c) && workQueue.offer(command)) {
//（4.1）二次检查
int recheck = ctl.get();
//（4.2）如果当前线程池状态不是RUNNING则从队列删除任务，并执行拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
//（4.3）否者如果当前线程池线程空，则添加一个线程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//（5）如果队列满了，则新增线程，新增失败则执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
启动工作线程并循环获取任务执行
基本认识：
从阻塞队列里获取任务的俩种情况:getTask()
- task=workQueue.take() 会阻塞，没有就会一直阻塞，只有有的时候才会继续执行返回（这个默认的核心线程会执行take））
- 非核心线程会调用（如果设置了核心线程也允许超时，则核心线程也会调用此方法去获取任务）
task=workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) - 核心线程和非核心线程的判断，就是先来的是核心线程，达到核心个数后再来的线程就是非核心了哦
过程总结：
-
cas操作AtomicInteger ctl，添加工作线程个数，添加不成功继续循环，直到成功修改了ctl,添加了工作线程个数
-
然后向全局工作线程集合中添加工作线程，此工作线程结合是个HashSet,线程不安全，所以需要拿到主锁mainLock，才可以进行添加。添加成功后启动线程执行任务。
-
创建一个任务并启动了一个worker后，worker执行完这个任务后会while循坏从阻塞队列里获取任务：
-
如果获取到了任务，则锁住worker自己（实现了AQS），执行run方法执行完毕后，释放锁，本worker完成任务数+1，completedTasks++,继续从阻塞队列获取任务
-
如果获取到的是null(超时),此时结束while循坏不再继续获取任务，此时将工作线程个数ctl-1,并从工作线程集合移除该worker,同时拿到本次completedTasks添加到全局已完成任务数
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
//（6） 检查队列是否只在必要时为空
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
//（7）循环cas增加线程个数
for (;;) {
int wc = workerCountOf(c);
//（7.1）如果线程个数超限则返回false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//（7.2）cas增加线程个数，同时只有一个线程成功
if (compareAndIncrementWorkerCount(c))
break retry;
//（7.3）cas失败了，则看线程池状态是否变化了，变化则跳到外层循环重试重新获取线程池状态，否者内层循环重新cas。
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
}
}
//（8）到这里说明cas成功了
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//（8.1）创建worker
final ReentrantLock mainLock = this.mainLock;
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
//（8.2）workers:池中所有工作线程的集合。仅在获取到主锁mainLock情况下访问（注释里说的）。
// private final HashSet<Worker> workers = new HashSet<Worker>()
// workers是HashSet,线程不安全，访问workers需要拿到mainlock进行上锁
// 这个在workers的注释里也有说明，只要在拿到mainlock情况下才可以访问
mainLock.lock();
try {
//（8.3）重新检查线程池状态，为了避免在获取锁前调用了shutdown接口
int c = ctl.get();
int rs = runStateOf(c);
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//（8.4）添加任务
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
//（8.5）添加成功则启动任务
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); //(9)status设置为0，允许中断
boolean completedAbruptly = true;
try {
//(10)
while (task != null || (task = getTask()) != null) {
//(10.1)
w.lock();
...
try {
//(10.2)任务执行前干一些事情
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();//(10.3)执行任务
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
//(10.4)任务执行完毕后干一些事情
afterExecute(task, thrown);
}
} finally {
task = null;
//(10.5)统计当前worker完成了多少个任务
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
//(11)执行清工作
processWorkerExit(w, completedAbruptly);
}
}
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;
}
}
}
private void processWorkerExit(Worker w, boolean completedAbruptly) {
...代码太长，这里就不展示了
//(11.1)统计整个线程池完成的任务个数,并从工作集里面删除当前woker
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
//(11.2)尝试设置线程池状态为TERMINATED，如果当前是shutdonw状态并且工作队列为空
//或者当前是stop状态当前线程池里面没有活动线程
tryTerminate();
//(11.3)如果当前线程个数小于核心个数，则增加
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}
shutdown 操作
总结：
-
调用 shutdown 后，线程池就不会在接受新的任务了但是工作队列里面的任务还是要执行
-
设置所有空闲线程的中断标志，这里首先加了全局锁，同时只有一个线程可以调用 shutdown 设置中断标志，然后尝试获取 worker 自己的锁，获取成功则设置中断标识，由于正在执行的任务已经获取了锁，所以正在执行的任务没有被中断。这里中断的是阻塞到 getTask() 方法企图从队列里面获取任务的线程，也就是空闲线程。
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//(12)权限检查
checkShutdownAccess();
//(13)设置当前线程池状态为SHUTDOWN，如果已经是SHUTDOWN则直接返回
advanceRunState(SHUTDOWN);
//(14)设置中断标志
interruptIdleWorkers();
onShutdown();
} finally {
mainLock.unlock();
}
//(15)尝试状态变为TERMINATED
tryTerminate();
}
shutdownNow 操作
调用 shutdownNow 后，线程池就不会在接受新的任务了，并且丢弃工作队列里面里面的任务，正在执行的任务会被中断，该方法是立刻返回的，并不等待激活的任务执行完成在返回。返回值为这时候队列里面被丢弃的任务列表。代码如下：
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();//（16)权限检查
advanceRunState(STOP);//(17) 设置线程池状态为stop
interruptWorkers();//(18)中断所有线程不需要获取锁，所以能中断正在执行的worker
tasks = drainQueue();//（19）移动队列任务到tasks
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
awaitTermination操作
当线程调用 awaitTermination 方法后，当前线程会被阻塞，知道线程池状态变为了 TERMINATED 才返回，或者等待时间超时才返回，整个过程独占锁,代码如下：
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (;;) {
if (runStateAtLeast(ctl.get(), TERMINATED))
return true;
if (nanos <= 0)
return false;
nanos = termination.awaitNanos(nanos);
}
} finally {
mainLock.unlock();
}
}
1943
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
