线程池顶层接口Executor
- Executor顶层接口，定义了一个方法execute，线程池执行线程的方法
- ExecutorService，我们利用Executors工具类创建的线程返回的就是这个接口，功能比较齐全，一般我们使用这个接口
- AbstractExecutorService定义了一些公用方法
- ThreadPoolExecutor，实现类，创建线程池与执行线程池等在这个方法中
Executors工具类
此类提供了一些线程池供我们使用
newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行
newSingleThreadExecuto
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
ExecutorService
主要方法
// 关闭线程池，已提交的任务继续执行，不接受继续提交新任务
void shutdown();
// 立即关闭线程池，不接受继续提交新任务，线程池中任务中断不执行
List<Runnable> shutdownNow();
// 线程池是否关闭
boolean isShutdown();
// shutdown() 或 shutdownNow() 方法后，所有任务结束了，执行这个方法，返回true
boolean isTerminated();
// 提交一个 Callable 任务
<T> Future<T> submit(Callable<T> task);
// 提交一个 Runnable 任务，第二个参数作为返回值，
<T> Future<T> submit(Runnable task, T result);
// 提交一个 Runnable 任务
Future<?> submit(Runnable task);
- 因为Executor顶层接口执行一个execute方法，此方法只会接受Runnable任务
- void execute(Runnable command);
- submit方法就是将callable类型的线程在线程池中执行，其实原理就是将callable、runnable转化位FutureTask，最终还是调用execute方法执行
//提交Runnable对象
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
//转化FutureTask对象
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;
}
//Callable 转化为 Runnable 对象
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
ThreadPoolExecutor
这个类实现了一个线程池需要的各个方法，它实现了任务提交、线程管理、监控等等方法。
参数最全的构造方法
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
...........................
}
corePoolSize：核心线程数，核心有多少个线程执行
maximumPoolSize：最大线程数，最多有多少个线程执行
keepAliveTime：空闲线程存活时间，非核心线程，最大线程的存活时间，在队列中寻找等待的时间
TimeUnit：时间单位
workQueue：阻塞队列，大于核心线程数的线程会放入阻塞队列，等待核心线程有线程执行完执行
ThreadFactory：线程池线程创建工厂、线程起名等，使用默认就可以
handler：拒绝策略，当线程池已经满了，但是又有新的任务提交的时候，线程池的拒绝策略。jdk定义有4种，我们也可以自己实现RejectedExecutionHandler接口实现方法。
RejectedExecutionHandler
AbortPolicy
抛出异常
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
DiscardPolicy
不做任务操作
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
DiscardOldestPolicy
抛弃队列头的任务，执行当前任务
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
CallerRunsPolicy
当前线程执行任务，不开启新的线程
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
executorService类属性
///默认状态是running，高3位是111（running） 低29为都是0，两个值组合位一个int类型的数据
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//int字节长度减3，高3为和低29位，用Integer.SIZE来保证不同jvm逻辑不变
private static final int COUNT_BITS = Integer.SIZE - 3;
///000 11111111111111111111111111111 1 << 29
//最大线程数，29个1
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// 线程池running状态
// 111 00000000000000000000000000000
// 111 29个0
private static final int RUNNING = -1 << COUNT_BITS;
// 000 00000000000000000000000000000
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 001 00000000000000000000000000000
private static final int STOP = 1 << COUNT_BITS;
// 010 00000000000000000000000000000
private static final int TIDYING = 2 << COUNT_BITS;
// 011 00000000000000000000000000000
private static final int TERMINATED = 3 << COUNT_BITS;
// 将整数 c 的低 29 位修改为 0，就得到了线程池的状态
private static int runStateOf(int c) { return c & ~CAPACITY; }
// 将整数 c 的高 3 为修改为 0，就得到了线程池中的线程数
private static int workerCountOf(int c) { return c & CAPACITY; }
//线程状态 + 线程个数 组合程一个整数
private static int ctlOf(int rs, int wc) { return rs | wc; }
- RUNNING，这是最正常的状态：接受新的任务，处理等待队列中的任务
- SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务
- STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程
- TIDYING：所有的任务都销毁了，workCount 为 0。线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()
- TERMINATED：terminated() 方法结束后，线程池的状态就会变成这个
executorService.execute()
submit最终调用的也是execute方法，我们最终看execute底层就可以了
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//获取线程个数 + 状态的int 32位整数
int c = ctl.get();
//如果线程池线城数小于核心线程数
if (workerCountOf(c) < corePoolSize) {
//将runnble任务加入到线程池中
if (addWorker(command, true))
return;
c = ctl.get();
}
//进到这里说明addworker失败或者线程池中线程数大于等于核心线程数
//线程状态是running并且加入队列成功
if (isRunning(c) && workQueue.offer(command)) {
//重新获取状态值
int recheck = ctl.get();
//再次检查线程池是否是running状态
if (! isRunning(recheck) && remove(command))
reject(command);
//如果线程池中没有线程了，则需要重新创建线程执行
//如果有线程，忽略，线程池会利用核心线程执行队列中的数据
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//如果入队失败，创建线程用最大线程执行
else if (!addWorker(command, false))
reject(command);
}
最主要的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;
//如果cas成功，结束循环
if (compareAndIncrementWorkerCount(c))
break retry;
//如果cas失败重新循环
c = ctl.get(); // Re-read ctl
//状态是否变了，如果状态变了需要跳到最外层的循环
if (runStateOf(c) != rs)
continue retry;
}
}
//线程加入成功
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//将当前任务加入到worker对象中
//什么叫firstTask
//就是核心线程中第一个任务
//其余任务都是核心线程执行完第一个任务后再次执行的
w = new Worker(firstTask);
//获取worker的线程，这个对象是我们主要的线程对象，这个就是我们创建的核心线程
final Thread t = w.thread;
if (t != null) {
//重入锁
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//获取状态
int rs = runStateOf(ctl.get());
//如果状态正常，或者是shutdown + 队列任务
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 final class Worker
extends AbstractQueuedSynchronizer
implements Runnable{
//任务执行的真实线程
final Thread thread;
//核心线程执行的第一个任务
Runnable firstTask;
volatile long completedTasks;
//任务封装到work对象
Worker(Runnable firstTask) {
setState(-1);
this.firstTask = firstTask;
//初始化线程，真实线程，靠他执行this任务
this.thread = getThreadFactory().newThread(this);
}
//执行线程run方法
public void run() {
//执行
runWorker(this);
}
}
final void runWorker(Worker w) {
//获取当前线程
Thread wt = Thread.currentThread();
//取第一个任务
Runnable task = w.firstTask;
//置空
w.firstTask = null;
w.unlock();
boolean completedAbruptly = true;
try {
//取任务，先取第一个任务，就是创建核心线程的任务
//如果第一个任务等于空，说明任务已经执行完了，我该用这个线程去队列中取任务了
//一个线程先执行创建这个线程的第一个任务，然后取队列，队列有数据取到执行，达到线程复用。如果没有取到，销毁线程
while (task != null || (task = getTask()) != null) {
w.lock();
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
//注意这个调用的run方法，不是线程的start方法
//此时已经在线程中呢，用这个线程执行任务
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);
}
}
- 取任务，先取第一个任务，就是创建核心线程的任务。如果不为空，执行这个任务
- 如果第一个任务等于空，说明任务已经执行完了，我该用这个线程去队列中取任务了，取到任务用刚刚的线程执行
- 一个线程先执行创建这个线程的第一个任务，然后取队列，队列有数据取到执行，达到线程复用。如果没有取到，销毁线程
- 注意这个task调用的是run方法，不是线程的start方法，此时已经在线程中呢，用这个线程执行任务，如果调用start方法那就又开启一个线程了，这个线程还不是线程池管理的，最后我们看下getTask方法
getTast 在队列中取任务
private Runnable getTask() {
//用于统计是否超时
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
//获取线程状态
int rs = runStateOf(c);
//如果线程状态大于shutdown 并且 大于 stop 队列为空
//没有任务，线程个数减减，结束，释放线程
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
//获取线程池中的线程个数
int wc = workerCountOf(c);
//判断核心线程是否需要销毁，默认为false 不销毁
//如果是非核心线程会，并且队列为空，直接返回，线程结束，就是销毁
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;
}
}
}
- 大致逻辑已经注释
- 主要是在队列中取任务，如果队列中有任务，用核心线程去执行，到达线程复用的效果
- 根据创建线程的时间去队列中取任务，超时没有取到任务则销毁线程
- 取到任务后，核心线程执行完第一个任务后（就是创建核心线程时的那个任务），取队列任务用当前的核心线程执行
- 如果核心线程有8个时，如果8个核心线程first task都执行完了，则会再次循环取队列任务，继续执行，超时取不到释放线程
以上就是线程池的大致源码分析，如有错误欢迎批评指正
794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
