线程池
线程池的创建
ThreadPoolExecutor 的主要构造方法
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
-
corePoolSize: 核心线程数大小，线程池中保持的线程数，即使线程是空闲的，没有任务需要处理，也会存在指定的线程数而不会被销毁，但是可以调用allowCoreThreadTimeOut方法，允许核心线程过期销毁 -
maximumPoolSize: 最大线程数， 线程池中最大允许的线程数 = 核心线程数 + 非核心线程数（非核心线程数在空闲的时候就会被销毁） -
keepAliveTime: 非核心线程数最长闲置时间，如果非核心线程在设置的这个时长都没有任务处理，就会被销毁， 但是当通过allowCoreThreadTimeOut（boolean）方法设置了运行核心线程过期销毁时，核心线程的销毁也会根据这个时间来进行销毁控制 -
unit: 线程最长闲置时间的单位 -
workQueue: 阻塞队列，放置等待被执行的Runnable任务 -
threadFactory: 线程工厂，用于创建线程并设置线程参数（如，是否是守护线程，线程名称，线程组）， 如果不指定这个参数，有默认的创建线程对象java.util.concurrent.Executors.DefaultThreadFactory#DefaultThreadFactory会设置默认的线程创建参数 -
handler: 拒绝策略，当线程池满了并且阻塞队列也满了的时候，会根据设置的拒绝策略，来拒绝新来的无法处理的任务，线程池提供了一下4种拒绝策略-
java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy: 如果线程池没有被shutdown , 则由调用该线程的线程去执行任务的run 方法， 如果线程池已经shutdown了，则该任务将被抛弃public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { r.run(); } } -
java.util.concurrent.ThreadPoolExecutor.AbortPolicy: 直接抛出RejectedExecutionException异常public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString()); } -
java.util.concurrent.ThreadPoolExecutor.DiscardPolicy: 默默丢弃任务，啥也不做，你甚至不知道他把你的任务丢弃了public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { } -
java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy: 如果线程池没有被shutdown，则丢弃阻塞队列中最老的任务，并且重新执行该任务，如果线程池已经被shutdown了则丢弃该任务public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { e.getQueue().poll(); e.execute(r); } }
-
线程池的状态
RUNNING: 运行中，可接收新任务并处理队列中的任务SHUTDOWN: 不会再接受新的任务，但是会处理队列中的任务STOP: 不会接受新的任务，不会处理队列中的任务，并且会打断正在运行中的任务TIDYING: 整理中， 所有任务都已经被终止，线程池中的线程为0，线程池过渡到该状态时，会运行terminated() 钩子方法， terminated() 方法默认的实现是空的，是一个钩子方法，用户可自定义操作TERMINATED： terminated() 方法已经被执行
重要概念
核心线程和非核心线程 在创建时并没有任何标识是核心线程和非核心线程，两者的区分由核心线程数量来区分，多余核心线程数的部分都为非核心线程，在线程销毁的时候，也不会指定销毁核心线程 或者非核心线程，而是任意的销毁某一个线程，使得线程池中线程数小于等于核心线程数
Worker : 线程池的线程由worker 封装了 , Worker 是ThreadPoolExecutor 中定义的类
Worker继承了AbstractQueuedSynchronizer，可见Worker实际是一个同步队列（实现了同步的，先进先出队列）
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
/** worker 中运行的线程 */
final Thread thread;
/** 初始的任务，可能为空 */
Runnable firstTask;
/** 每个线程完成任务的计数器 */
volatile long completedTasks;
-
Worker实现了Runnable接口，实际是一个可执行的任务，实现了线程运行时的run 方法public void run() { runWorker(this); } // 如果firstTask 不为空，或者阻塞队列中存在任务，则利用当前线程循环逐个执行这些任务，从而达到线程池的线程复用的目的 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(); // 如果线程池的状态是stop ,确保线程的状态会被终止，否则确保线程没有被终止 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 { // 当没有可执行的任务时， 从workers集合中移除当前worker, 并尝试终止一个线程， processWorkerExit(w, completedAbruptly); } } //自旋获取阻塞队列中任务，或者返回null // 返回null意味着runWorker()方法中的while循环会被退出，其对应的线程就要销毁了，也就是线程池中少了一个线程了 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); // 是否需要考虑销毁空闲的线程（是否需要考虑超时控制）， 当存在非核心线程或者 设置了allowCoreThreadTimeOut时，需要考虑 boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; // 如果当前线程数大于最大线程数或者需要考虑销毁空闲线程， 并且线程数大于1并且阻塞队列是空的 if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) // 尝试减少线程数量返回空 return null; continue; } try { // 从阻塞队列中获取任务 // poll 方法 ： 从缓存队列中取任务,最长等待keepAliveTime的时长，取不到返回null //take方法： 从缓存队列中取任务，若队列为空,则进入阻塞状态，直到能取出对象为止 Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } } -
线程池是如何实现线程的的复用？
- 线程创建完后一直由
worker持有，worker的run方法会一直使用当前线程循环自旋的获取阻塞队列中的任务并执行任务，当阻塞队列为空时进入阻塞状态，直到有新的任务进入，或者考虑到线程的超时空闲销毁，则会销毁多余的线程 - 当前线程就是在
addWorker方法 中创建并启动的线程
- 线程创建完后一直由
主要属性
/**
* 暂存任务的阻塞队列
*/
private final BlockingQueue<Runnable> workQueue;
/**
* 可重入锁
*/
private final ReentrantLock mainLock = new ReentrantLock();
/**
* 工作线程集合，只有当获取到可重入锁的时候才能操作该集合
*/
private final HashSet<Worker> workers = new HashSet<Worker>();
/**
* termination条件
*/
private final Condition termination = mainLock.newCondition();
/**
* 记录最大线程数，操作该属性需要获取可重入锁
*/
private int largestPoolSize;
/**
* 计算已完成任务数，只有当对应的工作线程终止了才会更新，操作该属性需要获取可重入锁
*/
private long completedTaskCount;
/*
* 以下属性都被 volatile 修饰，确保可见性，并且不需要加锁
*/
/**
* 创建线程的工厂，线程池中的所有线程都由threadFactory 创建，使用时要考虑到线程创建失败
*
*/
private volatile ThreadFactory threadFactory;
/**
* 拒绝策略，当线程池处于饱和状态或者shutdown 时执行
*/
private volatile RejectedExecutionHandler handler;
/**
* 线程最长闲置时间
*/
private volatile long keepAliveTime;
/**
* 是否设置核心线程在闲置时被销毁，如果是，则keepAliveTime 属性也将用于核心线程
*/
private volatile boolean allowCoreThreadTimeOut;
/**
* 核心线程数 = 最大线程数 - 非核心线程数
*/
private volatile int corePoolSize;
/**
* 最大线程数 = 核心线程数 + 非核心线程数
*/
private volatile int maximumPoolSize;
线程池的执行流程
execute 源码分析
ctl：private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));存储线程池的状态和线程数，高三位存线程状态， 其他位存线程数
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) // 如果线程池的状态是运行中，并且线程数为0，则新建线程
addWorker(null, false);
}
else if (!addWorker(command, false)) //如果任务添加到阻塞队列失败，则创建非核心线程并执行任务
reject(command); //如果添加线程并执行任务失败则执行拒绝策略
}
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(); // 重新读取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); // 新建一个worker(创建了一个线程)
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock(); // 获取可重入锁
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
// 重新检查线程池状态， 防止在获取可重入锁时线程池shutdow
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // 检查线程是否创建好了，防止ThreadFactory 创建线程失败
throw new IllegalThreadStateException();
workers.add(w); // 将新建的Worker 添加到workers 工作集合中
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s; // 更新最大线程数
workerAdded = true;
}
} finally {
mainLock.unlock(); // 解锁
}
if (workerAdded) { // 如果 worker 已成功添加，则开始执行新建的线程
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted) // 如果线程开启失败，则将新建的worker 从workers 集合中移除并修改线程池中的线程数，并且尝试终止线程池
addWorkerFailed(w);
}
return workerStarted;
}
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (w != null)
workers.remove(w); // 如果worker存在，则将其从workers 集合中移除
decrementWorkerCount(); // 减少线程池中的线程数
tryTerminate(); // 尝试终止线程池
} finally {
mainLock.unlock();
}
}
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) || // 线程池的状态为 运行中 或者
runStateAtLeast(c, TIDYING) || // 线程池的状态是 TIDYING 或者是 TERMINATED 或者
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty())) // 线程的状态是SHUTDOWN 并且工作队列不为空
return; // 直接返回，不修改线程池状态
// 只有shutdown状态 且 workQueue为空，或者 stop状态能执行到这一步
if (workerCountOf(c) != 0) { // 如果线程池中的线程数不为空，
interruptIdleWorkers(ONLY_ONE); // 中断线程池中一个空闲的线程 为什么此处只终止一个空闲线程 ？？？
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock(); // 获取锁
try {
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { // 尝试将线程池的状态修改为 TIDYING
try {
terminated();
} finally {
ctl.set(ctlOf(TERMINATED, 0)); // 将线程池状态变更为TERMINATED
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// 否则重新循环尝试校验并修改
}
}
execute 流程图
submit
概述
submit方法由ExecutorService接口提供，而不是由Executor提供，execute方法由executor接口提供AbstractExecutorService抽象类实现了该接口submit方法有返回值，执行完任务后可以返回由Future类型封装的执行结果，而execute方法无返回值
源码分析
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* 接收Runnable 类型的参数， 返回结果为空
*/
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* 接收Runnable 类型的参数， result作为返回对象的被封装结果，线程执行时可需修改对象的内容，但是不可修改该对象的内存地址
*/
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;
}
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* 接受callable类型的参数， 由于Callable的 call方法是有返回对象的，此方法的返回值就是call方法执行的返回值的封装
*/
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
callable，Future， FutureTask
Future
-
概述 ： 是一个接口，定义了获取线程执行结果，执行状态的相关方法
-
源码分析
/** * 尝试终止执行中的任务，如果已经被取消了或者由于其他原因未能取消则会失败 * 如果当执行该方法时，线程还未启动则该方法不会被执行 * 执行完这个方法后并且返回了成功，再调用 isDone 方法， isDone 方法会一直返回true * 再调用isCancelled 方法， isCancelled 方法会一直返回true * */ boolean cancel(boolean mayInterruptIfRunning); /** * Returns {@code true} if this task was cancelled before it completed * normally. * * @return {@code true} if this task was cancelled before it completed */ boolean isCancelled(); /** * 任务是否已结束，包括正常结束和非正常结束, FutureTask的实现是只要任务的状态不是初始化状态，就任务任务已经结束 * * @return {@code true} if this task completed */ boolean isDone(); /** * 获取线程的执行结果，如果线程还未执行完成，会一直阻塞等待完成然后获取结果 * * 返回计算的结果 * 如果任务已被取消 抛出CancellationException异常 * 如果在执行过程中出现异常 则抛出ExecutionException异常 */ V get() throws InterruptedException, ExecutionException; /** * 限时等待获取结果，如果超过设置的时间还没获取到结果抛出TimeoutException 异常 */ V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
FutureTask
-
概述：
futureTask是Runnable和Future的结合， 所以它既是一个可被线程执行对象（实现了 run 方法），又是一个可获取线程执行结果的类， 是对Futrue和Runnable的实现- 获取线程执行的结果主要是通过
LockSupport.park()和LockSupport.unPark()方法使得获取结果的线程等待和结束等待
-
源码
/** 可能的状态转换: * NEW -> COMPLETING -> NORMAL * NEW -> COMPLETING -> EXCEPTIONAL * NEW -> CANCELLED * NEW -> INTERRUPTING -> INTERRUPTED */ private volatile int state; // 任务执行的状态，以下定义了可能的状态值，volatile 修饰，确保他的可见性 private static final int NEW = 0; // 初始状态，新建 private static final int COMPLETING = 1; // 执行计算中 private static final int NORMAL = 2; // 正常完成 private static final int EXCEPTIONAL = 3; // 异常结束 private static final int CANCELLED = 4; // 被取消 private static final int INTERRUPTING = 5; // 终止中 private static final int INTERRUPTED = 6; // 已被终止 /** 定义要被执行的任务 */ private Callable<V> callable; /** 执行结果，可能是抛出的异常， get()方法的返回值 */ private Object outcome; // non-volatile, protected by state reads/writes /** 执行callable 任务的线程， 在run（）方法中通过 cas 的方式设置，将当前线程赋值给runner -- 妙啊 */ private volatile Thread runner; /** 等待获取结果的线程链表 */ private volatile WaitNode waiters;-
重要方法
-
构造方法可接收Callable 类型的参数，也可接受Runnable类型的参数， 会将Runnable 类型 通过 RunnableAdapter 适配器将 Runnable 接口转换为Callable 接口
/** * 接收 callable 类型的参数 */ public FutureTask(Callable<V> callable) { if (callable == null) throw new NullPointerException(); this.callable = callable; this.state = NEW; // ensure visibility of callable } /** * 接收runnable 类型的参数 * result 参数可为null, 传null时，如果执行正常,通过get方法获取的返回结果也是null， 如果执行异常，通过get可获取抛出的异常信息 */ public FutureTask(Runnable runnable, V result) { this.callable = Executors.callable(runnable, result); this.state = NEW; // ensure visibility of callable } /** * 通过包装将Runnable 接口转换适配成 Callable 类型的对象 */ static final class RunnableAdapter<T> implements Callable<T> { final Runnable task; final T result; RunnableAdapter(Runnable task, T result) { this.task = task; this.result = result; } public T call() { task.run(); return result; } } -
run 相关方法
- 概述： 维护任务的执行状态，执行任务，并将执行结果封装
UNSAFE.putOrderedInt设置值 并且马上写入主存，该变量必须是volatile类型
public void run() { // 检查任务执行的状态，如果不是初始化状态，则标识已被执行或者在执行中，则直接返回 // 通过cas 方式尝试修改 runner字段相对于对象的起始内存地址的字节偏移量（其实就是将runner 对象指向一个新的地址，从而实现对runner字段的修改 -- 不知道理解的对不对）， runner 指向当前线程--由此也可见run 方法并没有新建线程，futureTask 也没有新建线程 // 如果比较和修改成功，则表示runner 属性没有被修改过，可进行后续的流程 -- 隐式的校验runneroffset的值 if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread())) return; try { Callable<V> c = callable; if (c != null && state == NEW) { // 检查任务，再次检查状态 V result; boolean ran; try { result = c.call(); // 执行任务，将结果放入 resutl 对象中 ran = true; } catch (Throwable ex) { result = null; // 如果运行失败，则捕获异常 ran = false; setException(ex); // 封装异常，将异常封装到outcome对象，并修改状态 } if (ran) // 如果执行完成 set(result); // 封装执行结果 } } finally { // runner 设置为空，要确保先状态修改完成，防止并发调用 run方法 runner = null; // 重新检查状态，防止中断操作被遗漏 int s = state; if (s >= INTERRUPTING) //如果状态是打断中，或者已经被打断，则中断当前线程的执行，让出cup的执行时间 handlePossibleCancellationInterrupt(s); } } protected void setException(Throwable t) { // 通过cas 的方式修改状态，new 状态转换 为 执行中状态 ， 同时隐式的对状态进行了校验 if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { outcome = t; // 将异常赋值给输出结果， 通过get 方法可获取该异常 UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // 将状态设置为 Exceptional状态，并且立马写入内存 finishCompletion(); } } /** * 将正常的执行结果保存到 outcome 中，并且更新状态 */ protected void set(V v) { // 校验并且更新状态 if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { outcome = v; UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // 将状态设置为 normal表示正常结束 finishCompletion(); } } /** 任务结束（取消，正常结束，异常结束）都会调用该方法 * 移除并且通知waitNode线程等待队列， 调用 done()方法, 并且将 callabe 任务设置为空 */ private void finishCompletion() { // 调用此方法需要确保 state > COMPLETING 即状态是一个终止状态; // q 指向waiters的内容，使得置空了waiters后（将waiters指向null）还能被获取 waitNode的内容（线程，下一个节点） for (WaitNode q; (q = waiters) != null;) { // 将waiters置空（指向空）， if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) { // 循环清除等待队列中的线程的关联 for (;;) { Thread t = q.thread; if (t != null) { q.thread = null; LockSupport.unpark(t); // 使得线程t结束等待状态继续执行 (线程t可能在获取结果的get()方法中进入了等待状态) } WaitNode next = q.next; if (next == null) break; q.next = null; // unlink to help gc q = next; } break; } } done(); // FutureTask 的 done 方法是一个空的实现，子类可自定义计算完成后的操作 callable = null; // to reduce footprint } -
get 相关方法
- 在获取结果时如果任务未执行完成，则调用
LockSupport.park()方法使得当前线程进入等待状态，等待任务完成后（调用完finishCompletion方法）的LockSupport.unPark()通知使得线程继续执行
/** * 获取线程的执行结果，如果未完成，则进行阻塞 */ public V get() throws InterruptedException, ExecutionException { int s = state; if (s <= COMPLETING) // 如果任务执行状态不是最终状态 （正常结束，异常结束，取消，中断），则等待任务的完成 s = awaitDone(false, 0L); return report(s); } /** * 等待任务的完成（正常完成或者异常结束） * timed 为true 时可设置超时退出等待 */ private int awaitDone(boolean timed, long nanos) throws InterruptedException { final long deadline = timed ? System.nanoTime() + nanos : 0L; WaitNode q = null; boolean queued = false; // 自旋遍历等待队列中的等待线程节点 for (;;) { // 如果当前线程被打断了，则将当前线程从等待队列中移除，然后抛出中断移除 if (Thread.interrupted()) { removeWaiter(q); // 将当前等待线程从等待队列中移除 throw new InterruptedException(); } int s = state; // 如果任务已经是完成状态 if (s > COMPLETING) { if (q != null) //如果等待节点不为空，将等待节点的线程指向null q.thread = null; return s; // 返回任务的状态 } else if (s == COMPLETING) // 如果任务还在执行中，则通Thread.yield 方法让出当前线程cup的执行权 Thread.yield(); else if (q == null) // 如果等待队列是空的则初始化等待队列, 将当前线程封装到等待节点中 q = new WaitNode(); else if (!queued) // 初始化等待队列，设置队列的next节点 queued = UNSAFE.compareAndSwapObject(this, waitersOffset, q.next = waiters, q); else if (timed) { // 如果设置了超时时间 nanos = deadline - System.nanoTime(); if (nanos <= 0L) { // 超时还未完成 removeWaiter(q); // 将当前等待线程从等待队列中移除 return state; } LockSupport.parkNanos(this, nanos); // 指定线程的等待时间 } else LockSupport.park(this); // 使得当前线程进入等待状态 } } /** *返回任务的结果或者异常 */ @SuppressWarnings("unchecked") private V report(int s) throws ExecutionException { Object x = outcome; if (s == NORMAL) // 如果是正常结束的，则之间返回运行结果 return (V)x; if (s >= CANCELLED) // 如果任务被取消，或者被终止,则抛出CancellationException 异常 throw new CancellationException(); throw new ExecutionException((Throwable)x); // 如果执行时出现异常，则将异常封装 } - 在获取结果时如果任务未执行完成，则调用
-
-
1268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
