三.EventLoop
类图
EventExecutor 继承EventExecutorGroup接口，事件执行器接口
public interface EventExecutor extends EventExecutorGroup {
//返回自己
@Override
EventExecutor next();
//当前线程所处的EventExecutorGroup
EventExecutorGroup parent();
//当前线程是否在EventLoop线程中
boolean inEventLoop();
//指定线程是否是EventLoop线程
boolean inEventLoop(Thread thread);
//创建一个Promise对象
<V> Promise<V> newPromise();
//创建一个ProgressivePromise对象
<V> ProgressivePromise<V> newProgressivePromise();
//创建成功结果的Future对象
<V> Future<V> newSucceededFuture(V result);
//创建异常的Future对象
<V> Future<V> newFailedFuture(Throwable cause);
}
OrderedEventExecutor 有序的事件执行器接口
//表示该执行器会有序/串行的方式执行
public interface OrderedEventExecutor extends EventExecutor {
}
EventLoop
public interface EventLoop extends OrderedEventExecutor, EventLoopGroup {
@Override
//覆写方法的返回类型为 EventLoopGroup
EventLoopGroup parent();
}
AbstractEventExecutor
public abstract class AbstractEventExecutor extends AbstractExecutorService implements EventExecutor {
private static final InternalLogger logger = InternalLoggerFactory.getInstance(AbstractEventExecutor.class);
static final long DEFAULT_SHUTDOWN_QUIET_PERIOD = 2;
static final long DEFAULT_SHUTDOWN_TIMEOUT = 15;
//所属的EventExecutorGroup
private final EventExecutorGroup parent;
//EventExecutor数组，只包含自己
private final Collection<EventExecutor> selfCollection = Collections.<EventExecutor>singleton(this);
protected AbstractEventExecutor() {
this(null);
}
protected AbstractEventExecutor(EventExecutorGroup parent) {
this.parent = parent;
}
//获得所属的EventExecutorGroup
@Override
public EventExecutorGroup parent() {
return parent;
}
//获得自己
@Override
public EventExecutor next() {
return this;
}
//判断当前线程是否在EventLoop线程中
@Override
public boolean inEventLoop() {
return inEventLoop(Thread.currentThread());
}
@Override
public Iterator<EventExecutor> iterator() {
return selfCollection.iterator();
}
@Override
public Future<?> shutdownGracefully() {
return shutdownGracefully(DEFAULT_SHUTDOWN_QUIET_PERIOD, DEFAULT_SHUTDOWN_TIMEOUT, TimeUnit.SECONDS);
}
//关闭执行器
@Override
@Deprecated
public abstract void shutdown();
@Override
@Deprecated
public List<Runnable> shutdownNow() {
shutdown();
return Collections.emptyList();
}
@Override
public <V> Promise<V> newPromise() {
return new DefaultPromise<V>(this);
}
@Override
public <V> ProgressivePromise<V> newProgressivePromise() {
return new DefaultProgressivePromise<V>(this);
}
//创建成功结果
@Override
public <V> Future<V> newSucceededFuture(V result) {
return new SucceededFuture<V>(this, result);
}
//创建异常的Future对象
@Override
public <V> Future<V> newFailedFuture(Throwable cause) {
return new FailedFuture<V>(this, cause);
}
//提交任务
@Override
public Future<?> submit(Runnable task) {
return (Future<?>) super.submit(task);
}
@Override
public <T> Future<T> submit(Runnable task, T result) {
return (Future<T>) super.submit(task, result);
}
@Override
public <T> Future<T> submit(Callable<T> task) {
return (Future<T>) super.submit(task);
}
//创建PromiseTask对象
@Override
protected final <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new PromiseTask<T>(this, runnable, value);
}
@Override
protected final <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new PromiseTask<T>(this, callable);
}
@Override
public ScheduledFuture<?> schedule(Runnable command, long delay,
TimeUnit unit) {
throw new UnsupportedOperationException();
}
@Override
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
throw new UnsupportedOperationException();
}
@Override
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
throw new UnsupportedOperationException();
}
@Override
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
throw new UnsupportedOperationException();
}
//安全的执行任务
protected static void safeExecute(Runnable task) {
try {
task.run();
} catch (Throwable t) {
//发生异常的时候打印警告日志
logger.warn("A task raised an exception. Task: {}", task, t);
}
}
@UnstableApi
public void lazyExecute(Runnable task) {
execute(task);
}
@UnstableApi
public interface LazyRunnable extends Runnable { }
}
SingleThreadEventExecutor 基于单线程的 EventExecutor 抽象类，即一个EventExecutor对应一个线程
public abstract class SingleThreadEventExecutor extends AbstractScheduledEventExecutor implements OrderedEventExecutor {
static final int DEFAULT_MAX_PENDING_EXECUTOR_TASKS = Math.max(16,
SystemPropertyUtil.getInt("io.netty.eventexecutor.maxPendingTasks", Integer.MAX_VALUE));
private static final InternalLogger logger =
InternalLoggerFactory.getInstance(SingleThreadEventExecutor.class);
//未开始
private static final int ST_NOT_STARTED = 1;
//已开始
private static final int ST_STARTED = 2;
//正在关闭中
private static final int ST_SHUTTING_DOWN = 3;
//已关闭
private static final int ST_SHUTDOWN = 4;
//已经终止
private static final int ST_TERMINATED = 5;
private static final Runnable NOOP_TASK = new Runnable() {
@Override
public void run() {
// Do nothing.
}
};
//state字段的原子更新器
private static final AtomicIntegerFieldUpdater<SingleThreadEventExecutor> STATE_UPDATER =
AtomicIntegerFieldUpdater.newUpdater(SingleThreadEventExecutor.class, "state");
//thread字段的原子更新器
private static final AtomicReferenceFieldUpdater<SingleThreadEventExecutor, ThreadProperties> PROPERTIES_UPDATER =
AtomicReferenceFieldUpdater.newUpdater(
SingleThreadEventExecutor.class, ThreadProperties.class, "threadProperties");
//任务队列
private final Queue<Runnable> taskQueue;
//线程
private volatile Thread thread;
//线程属性
@SuppressWarnings("unused")
private volatile ThreadProperties threadProperties;
//执行器
private final Executor executor;
//线程是否已经打断
private volatile boolean interrupted;
//线程锁
private final CountDownLatch threadLock = new CountDownLatch(1);
private final Set<Runnable> shutdownHooks = new LinkedHashSet<Runnable>();
//添加任务时，是否唤醒线程
private final boolean addTaskWakesUp;
//最大等待执行任务数量
private final int maxPendingTasks;
//拒绝执行处理器
private final RejectedExecutionHandler rejectedExecutionHandler;
//最后执行时间
private long lastExecutionTime;
//状态
@SuppressWarnings({ "FieldMayBeFinal", "unused" })
private volatile int state = ST_NOT_STARTED;
private volatile long gracefulShutdownQuietPeriod;
//优雅关闭超时时间
private volatile long gracefulShutdownTimeout;
//优雅关闭开始时间
private long gracefulShutdownStartTime;
private final Promise<?> terminationFuture = new DefaultPromise<Void>(GlobalEventExecutor.INSTANCE);
protected SingleThreadEventExecutor(
EventExecutorGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp) {
this(parent, new ThreadPerTaskExecutor(threadFactory), addTaskWakesUp);
}
protected SingleThreadEventExecutor(
EventExecutorGroup parent, ThreadFactory threadFactory,
boolean addTaskWakesUp, int maxPendingTasks, RejectedExecutionHandler rejectedHandler) {
this(parent, new ThreadPerTaskExecutor(threadFactory), addTaskWakesUp, maxPendingTasks, rejectedHandler);
}
protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor, boolean addTaskWakesUp) {
this(parent, executor, addTaskWakesUp, DEFAULT_MAX_PENDING_EXECUTOR_TASKS, RejectedExecutionHandlers.reject());
}
protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,
boolean addTaskWakesUp, int maxPendingTasks,
RejectedExecutionHandler rejectedHandler) {
super(parent);
this.addTaskWakesUp = addTaskWakesUp;
this.maxPendingTasks = Math.max(16, maxPendingTasks);
this.executor = ThreadExecutorMap.apply(executor, this);
taskQueue = newTaskQueue(this.maxPendingTasks);
rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
}
protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,
boolean addTaskWakesUp, Queue<Runnable> taskQueue,
RejectedExecutionHandler rejectedHandler) {
super(parent);
this.addTaskWakesUp = addTaskWakesUp;
this.maxPendingTasks = DEFAULT_MAX_PENDING_EXECUTOR_TASKS;
this.executor = ThreadExecutorMap.apply(executor, this);
this.taskQueue = ObjectUtil.checkNotNull(taskQueue, "taskQueue");
this.rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
}
//创建任务队列
@Deprecated
protected Queue<Runnable> newTaskQueue() {
return newTaskQueue(maxPendingTasks);
}
protected Queue<Runnable> newTaskQueue(int maxPendingTasks) {
return new LinkedBlockingQueue<Runnable>(maxPendingTasks);
}
//打断线程
protected void interruptThread() {
Thread currentThread = thread;
//线程不存在，则标记线程被打断
if (currentThread == null) {
interrupted = true;
} else {
//打断线程
currentThread.interrupt();
}
}
//获得队头的任务
protected Runnable pollTask() {
assert inEventLoop();
return pollTaskFrom(taskQueue);
}
protected static Runnable pollTaskFrom(Queue<Runnable> taskQueue) {
for (;;) {
//获得并且移除队首元素，如果获得不到，返回Null
Runnable task = taskQueue.poll();
// 忽略 WAKEUP_TASK 任务，因为是空任务
if (task != WAKEUP_TASK) {
return task;
}
}
}
protected Runnable takeTask() {
assert inEventLoop();
if (!(taskQueue instanceof BlockingQueue)) {
throw new UnsupportedOperationException();
}
BlockingQueue<Runnable> taskQueue = (BlockingQueue<Runnable>) this.taskQueue;
for (;;) {
ScheduledFutureTask<?> scheduledTask = peekScheduledTask();
if (scheduledTask == null) {
Runnable task = null;
try {
task = taskQueue.take();
if (task == WAKEUP_TASK) {
task = null;
}
} catch (InterruptedException e) {
// Ignore
}
return task;
} else {
long delayNanos = scheduledTask.delayNanos();
Runnable task = null;
if (delayNanos > 0) {
try {
task = taskQueue.poll(delayNanos, TimeUnit.NANOSECONDS);
} catch (InterruptedException e) {
// Waken up.
return null;
}
}
if (task == null) {
fetchFromScheduledTaskQueue();
task = taskQueue.poll();
}
if (task != null) {
return task;
}
}
}
}
//将定时任务队列到达可执行的任务，添加到任务队列中
private boolean fetchFromScheduledTaskQueue() {
if (scheduledTaskQueue == null || scheduledTaskQueue.isEmpty()) {
return true;
}
//获得当前时间
long nanoTime = AbstractScheduledEventExecutor.nanoTime();
for (;;) {
//获得当前时间内，定时任务队列首个可执行的任务，并且从队列中移除
Runnable scheduledTask = pollScheduledTask(nanoTime);
if (scheduledTask == null) {
return true;
}
//将定时任务添加到taskQueue
if (!taskQueue.offer(scheduledTask)) {
//将定时任务添加回scheduledTaskQueue中
scheduledTaskQueue.add((ScheduledFutureTask<?>) scheduledTask);
return false;
}
}
}
private boolean executeExpiredScheduledTasks() {
if (scheduledTaskQueue == null || scheduledTaskQueue.isEmpty()) {
return false;
}
long nanoTime = AbstractScheduledEventExecutor.nanoTime();
Runnable scheduledTask = pollScheduledTask(nanoTime);
if (scheduledTask == null) {
return false;
}
do {
safeExecute(scheduledTask);
} while ((scheduledTask = pollScheduledTask(nanoTime)) != null);
return true;
}
//返回队头的任务，但是不移除
protected Runnable peekTask() {
assert inEventLoop();
return taskQueue.peek();
}
//队列中是否有任务
protected boolean hasTasks() {
assert inEventLoop();
return !taskQueue.isEmpty();
}
//获得队列中的任务数
public int pendingTasks() {
return taskQueue.size();
}
//在offerTask的基础上，如果添加任务到队列中失败，则进行拒绝任务
protected void addTask(Runnable task) {
ObjectUtil.checkNotNull(task, "task");
//添加任务到队列
if (!offerTask(task)) {
//添加失败，就拒绝任务
reject(task);
}
}
//添加任务到任务队列中，如果添加失败就返回false
final boolean offerTask(Runnable task) {
if (isShutdown()) {
reject();
}
//添加任务到队列
return taskQueue.offer(task);
}
//移除指定任务
protected boolean removeTask(Runnable task) {
return taskQueue.remove(ObjectUtil.checkNotNull(task, "task"));
}
//执行所有任务直到完成所有
protected boolean runAllTasks() {
assert inEventLoop();
boolean fetchedAll;
//是否执行过任务
boolean ranAtLeastOne = false;
do {
//从定时任务获得到时间的任务
fetchedAll = fetchFromScheduledTaskQueue();
//执行任务队列中的所有任务
if (runAllTasksFrom(taskQueue)) {
//若有任务执行，则标记为true
ranAtLeastOne = true;
}
} while (!fetchedAll); // keep on processing until we fetched all scheduled tasks.
//如果执行过任务，则设置最后执行时间
if (ranAtLeastOne) {
lastExecutionTime = ScheduledFutureTask.nanoTime();
}
//执行所有任务完成的后续方法
afterRunningAllTasks();
return ranAtLeastOne;
}
protected final boolean runScheduledAndExecutorTasks(final int maxDrainAttempts) {
assert inEventLoop();
boolean ranAtLeastOneTask;
int drainAttempt = 0;
do {
// We must run the taskQueue tasks first, because the scheduled tasks from outside the EventLoop are queued
// here because the taskQueue is thread safe and the scheduledTaskQueue is not thread safe.
ranAtLeastOneTask = runExistingTasksFrom(taskQueue) | executeExpiredScheduledTasks();
} while (ranAtLeastOneTask && ++drainAttempt < maxDrainAttempts);
if (drainAttempt > 0) {
lastExecutionTime = ScheduledFutureTask.nanoTime();
}
afterRunningAllTasks();
return drainAttempt > 0;
}
//执行任务队列中的所有任务
protected final boolean runAllTasksFrom(Queue<Runnable> taskQueue) {
//获得队头的任务
Runnable task = pollTaskFrom(taskQueue);
//获取不到就返回false
if (task == null) {
return false;
}
for (;;) {
//执行任务
safeExecute(task);
//获得队头的任务
task = pollTaskFrom(taskQueue);
//获取不到，结束执行，返回true
if (task == null) {
return true;
}
}
}
private boolean runExistingTasksFrom(Queue<Runnable> taskQueue) {
Runnable task = pollTaskFrom(taskQueue);
if (task == null) {
return false;
}
int remaining = Math.min(maxPendingTasks, taskQueue.size());
safeExecute(task);
// Use taskQueue.poll() directly rather than pollTaskFrom() since the latter may
// silently consume more than one item from the queue (skips over WAKEUP_TASK instances)
while (remaining-- > 0 && (task = taskQueue.poll()) != null) {
safeExecute(task);
}
return true;
}
//执行所有任务直到完成所有，或者超过执行时间上限
protected boolean runAllTasks(long timeoutNanos) {
//从定时任务获得到时间的任务
fetchFromScheduledTaskQueue();
//获得队头的任务
Runnable task = pollTask();
//获取不到，结束执行
if (task == null) {
//执行所有任务完成的后续方法
afterRunningAllTasks();
return false;
}
//计算执行任务截止时间
final long deadline = timeoutNanos > 0 ? ScheduledFutureTask.nanoTime() + timeoutNanos : 0;
//执行任务计数
long runTasks = 0;
long lastExecutionTime;
//循环执行任务
for (;;) {
//执行任务
safeExecute(task);
//计数+1
runTasks ++;
//每隔64个任务检查一次时间
if ((runTasks & 0x3F) == 0) {
//重新获得时间
lastExecutionTime = ScheduledFutureTask.nanoTime();
//超过任务截止时间，结束
if (lastExecutionTime >= deadline) {
break;
}
}
//获得队头的任务
task = pollTask();
if (task == null) {
lastExecutionTime = ScheduledFutureTask.nanoTime();
break;
}
}
//执行所有任务完成的后续方法
afterRunningAllTasks();
//设置最后执行时间
this.lastExecutionTime = lastExecutionTime;
return true;
}
@UnstableApi
protected void afterRunningAllTasks() { }
protected long delayNanos(long currentTimeNanos) {
ScheduledFutureTask<?> scheduledTask = peekScheduledTask();
if (scheduledTask == null) {
return SCHEDULE_PURGE_INTERVAL;
}
return scheduledTask.delayNanos(currentTimeNanos);
}
@UnstableApi
protected long deadlineNanos() {
ScheduledFutureTask<?> scheduledTask = peekScheduledTask();
if (scheduledTask == null) {
return nanoTime() + SCHEDULE_PURGE_INTERVAL;
}
return scheduledTask.deadlineNanos();
}
protected void updateLastExecutionTime() {
lastExecutionTime = ScheduledFutureTask.nanoTime();
}
protected abstract void run();
protected void cleanup() {
// NOOP
}
//唤醒线程
protected void wakeup(boolean inEventLoop) {
if (!inEventLoop) {
taskQueue.offer(WAKEUP_TASK);
}
}
//判断指定线程是否是EventLoop线程
@Override
public boolean inEventLoop(Thread thread) {
return thread == this.thread;
}
public void addShutdownHook(final Runnable task) {
if (inEventLoop()) {
shutdownHooks.add(task);
} else {
execute(new Runnable() {
@Override
public void run() {
shutdownHooks.add(task);
}
});
}
}
public void removeShutdownHook(final Runnable task) {
if (inEventLoop()) {
shutdownHooks.remove(task);
} else {
execute(new Runnable() {
@Override
public void run() {
shutdownHooks.remove(task);
}
});
}
}
private boolean runShutdownHooks() {
boolean ran = false
while (!shutdownHooks.isEmpty()) {
//拷贝shutdownHook任务
List<Runnable> copy = new ArrayList<Runnable>(shutdownHooks);
shutdownHooks.clear();
for (Runnable task: copy) {
try {
task.run();
} catch (Throwable t) {
logger.warn("Shutdown hook raised an exception.", t);
} finally {
ran = true;
}
}
}
if (ran) {
lastExecutionTime = ScheduledFutureTask.nanoTime();
}
return ran;
}
//优雅关闭
@Override
public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) {
ObjectUtil.checkPositiveOrZero(quietPeriod, "quietPeriod");
if (timeout < quietPeriod) {
throw new IllegalArgumentException(
"timeout: " + timeout + " (expected >= quietPeriod (" + quietPeriod + "))");
}
ObjectUtil.checkNotNull(unit, "unit");
//正在关闭阻止其他线程
if (isShuttingDown()) {
return terminationFuture();
}
boolean inEventLoop = inEventLoop();
boolean wakeup;
int oldState;
for (;;) {
if (isShuttingDown()) {
//正在关闭阻止其他线程
return terminationFuture();
}
int newState;
wakeup = true;
oldState = state;
if (inEventLoop) {
newState = ST_SHUTTING_DOWN;
} else {
switch (oldState) {
case ST_NOT_STARTED:
case ST_STARTED:
newState = ST_SHUTTING_DOWN;
break;
default:
//线程修改好线程状态
newState = oldState;
wakeup = false;
}
}
if (STATE_UPDATER.compareAndSet(this, oldState, newState)) {
//保证只有一个线程将oldState修改成newState
break;
}
}
//在default情况下更新这两个值
gracefulShutdownQuietPeriod = unit.toNanos(quietPeriod);
gracefulShutdownTimeout = unit.toNanos(timeout);
if (ensureThreadStarted(oldState)) {
return terminationFuture;
}
if (wakeup) {
taskQueue.offer(WAKEUP_TASK);
if (!addTaskWakesUp) {
wakeup(inEventLoop);
}
}
return terminationFuture();
}
@Override
public Future<?> terminationFuture() {
return terminationFuture;
}
@Override
@Deprecated
public void shutdown() {
if (isShutdown()) {
return;
}
boolean inEventLoop = inEventLoop();
boolean wakeup;
int oldState;
for (;;) {
if (isShuttingDown()) {
return;
}
int newState;
wakeup = true;
oldState = state;
if (inEventLoop) {
newState = ST_SHUTDOWN;
} else {
switch (oldState) {
case ST_NOT_STARTED:
case ST_STARTED:
case ST_SHUTTING_DOWN:
newState = ST_SHUTDOWN;
break;
default:
newState = oldState;
wakeup = false;
}
}
if (STATE_UPDATER.compareAndSet(this, oldState, newState)) {
break;
}
}
if (ensureThreadStarted(oldState)) {
return;
}
if (wakeup) {
taskQueue.offer(WAKEUP_TASK);
if (!addTaskWakesUp) {
wakeup(inEventLoop);
}
}
}
@Override
public boolean isShuttingDown() {
return state >= ST_SHUTTING_DOWN;
}
//将线程状态设置为关闭
@Override
public boolean isShutdown() {
return state >= ST_SHUTDOWN;
}
@Override
public boolean isTerminated() {
return state == ST_TERMINATED;
}
/**
* Confirm that the shutdown if the instance should be done now!
*/
protected boolean confirmShutdown() {
//没有调用shutdown相关的方法直接返回
if (!isShuttingDown()) {
return false;
}
if (!inEventLoop()) {
throw new IllegalStateException("must be invoked from an event loop");
}
//取消调度任务
cancelScheduledTasks();
//优雅关闭开始时间
if (gracefulShutdownStartTime == 0) {
gracefulShutdownStartTime = ScheduledFutureTask.nanoTime();
}
//执行完普通任务或者没有普通任务时执行完shutdownHook任务
if (runAllTasks() || runShutdownHooks()) {
if (isShutdown()) {
//调用shutdown方法直接退出
return true;
}
if (gracefulShutdownQuietPeriod == 0) {
//优雅关闭静默时间为0也直接退出
return true;
}
//优雅关闭但有未执行任务，唤醒线程执行
taskQueue.offer(WAKEUP_TASK);
return false;
}
final long nanoTime = ScheduledFutureTask.nanoTime();
//优雅关闭截止时间也返回
if (isShutdown() || nanoTime - gracefulShutdownStartTime > gracefulShutdownTimeout) {
return true;
}
//在静默期间每100ms唤醒线程执行期间提交的任务
if (nanoTime - lastExecutionTime <= gracefulShutdownQuietPeriod) {
taskQueue.offer(WAKEUP_TASK);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// Ignore
}
return false;
}
return true;
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
ObjectUtil.checkNotNull(unit, "unit");
if (inEventLoop()) {
throw new IllegalStateException("cannot await termination of the current thread");
}
threadLock.await(timeout, unit);
return isTerminated();
}
//执行一个任务
@Override
public void execute(Runnable task) {
ObjectUtil.checkNotNull(task, "task");
execute(task, !(task instanceof LazyRunnable) && wakesUpForTask(task));
}
@Override
public void lazyExecute(Runnable task) {
execute(ObjectUtil.checkNotNull(task, "task"), false);
}
private void execute(Runnable task, boolean immediate) {
//获得当前是否在EventLoop的线程中
boolean inEventLoop = inEventLoop();
//添加到任务队列
addTask(task);
if (!inEventLoop) {
//创建线程
startThread();
//如果已经关闭，移除任务并且进行拒绝
if (isShutdown()) {
boolean reject = false;
try {
if (removeTask(task)) {
reject = true;
}
} catch (UnsupportedOperationException e) {
}
if (reject) {
reject();
}
}
}
//唤醒线程
if (!addTaskWakesUp && immediate) {
wakeup(inEventLoop);
}
}
//执行多个普通任务，有一个执行完成即可
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
throwIfInEventLoop("invokeAny");
return super.invokeAny(tasks);
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
throwIfInEventLoop("invokeAny");
return super.invokeAny(tasks, timeout, unit);
}
//执行多个普通任务
@Override
public <T> List<java.util.concurrent.Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException {
throwIfInEventLoop("invokeAll");
return super.invokeAll(tasks);
}
@Override
public <T> List<java.util.concurrent.Future<T>> invokeAll(
Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException {
throwIfInEventLoop("invokeAll");
return super.invokeAll(tasks, timeout, unit);
}
//判断若在EventLoop的线程中调用该方法
private void throwIfInEventLoop(String method) {
if (inEventLoop()) {
throw new RejectedExecutionException("Calling " + method + " from within the EventLoop is not allowed");
}
}
//获得EventLoop的线程属性
public final ThreadProperties threadProperties() {
ThreadProperties threadProperties = this.threadProperties;
if (threadProperties == null) {
Thread thread = this.thread;
if (thread == null) {
assert !inEventLoop();
//提交空任务，促使execute方法执行
submit(NOOP_TASK).syncUninterruptibly();
//获得线程
thread = this.thread;
assert thread != null;
}
//创建DefaultThreadProperties对象
threadProperties = new DefaultThreadProperties(thread);
//CAS修改属性
if (!PROPERTIES_UPDATER.compareAndSet(this, null, threadProperties)) {
threadProperties = this.threadProperties;
}
}
return threadProperties;
}
@Deprecated
protected interface NonWakeupRunnable extends LazyRunnable { }
//判断该任务是否需要唤醒线程
protected boolean wakesUpForTask(Runnable task) {
return true;
}
protected static void reject() {
throw new RejectedExecutionException("event executor terminated");
}
//拒绝任务
protected final void reject(Runnable task) {
//拒绝执行器来拒绝任务
rejectedExecutionHandler.rejected(task, this);
}
private static final long SCHEDULE_PURGE_INTERVAL = TimeUnit.SECONDS.toNanos(1);
//启动EventLoop独占的线程
private void startThread() {
if (state == ST_NOT_STARTED) {
if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
//是否启动成功
boolean success = false;
try {
doStartThread();
//将标志位设置为成功
success = true;
} finally {
if (!success) {
STATE_UPDATER.compareAndSet(this, ST_STARTED, ST_NOT_STARTED);
}
}
}
}
}
private boolean ensureThreadStarted(int oldState) {
if (oldState == ST_NOT_STARTED) {
try {
doStartThread();
} catch (Throwable cause) {
STATE_UPDATER.set(this, ST_TERMINATED);
terminationFuture.tryFailure(cause);
if (!(cause instanceof Exception)) {
// Also rethrow as it may be an OOME for example
PlatformDependent.throwException(cause);
}
return true;
}
}
return false;
}
//启动独占的线程
private void doStartThread() {
assert thread == null;
executor.execute(new Runnable() {
@Override
public void run() {
//记录当前的线程
thread = Thread.currentThread();
//如果当前的线程已经被标记打断，就进行打断
if (interrupted) {
thread.interrupt();
}
//是否执行成功
boolean success = false;
//更新最后一次执行时间
updateLastExecutionTime();
try {
//执行任务
SingleThreadEventExecutor.this.run();
//标记执行成功
success = true;
} catch (Throwable t) {
logger.warn("Unexpected exception from an event executor: ", t);
} finally {
for (;;) {
int oldState = state;
if (oldState >= ST_SHUTTING_DOWN || STATE_UPDATER.compareAndSet(
SingleThreadEventExecutor.this, oldState, ST_SHUTTING_DOWN)) {
break;
}
}
// Check if confirmShutdown() was called at the end of the loop.
if (success && gracefulShutdownStartTime == 0) {
if (logger.isErrorEnabled()) {
logger.error("Buggy " + EventExecutor.class.getSimpleName() + " implementation; " +
SingleThreadEventExecutor.class.getSimpleName() + ".confirmShutdown() must " +
"be called before run() implementation terminates.");
}
}
try {
for (;;) {
if (confirmShutdown()) {
break;
}
}
for (;;) {
int oldState = state;
if (oldState >= ST_SHUTDOWN || STATE_UPDATER.compareAndSet(
SingleThreadEventExecutor.this, oldState, ST_SHUTDOWN)) {
break;
}
}
confirmShutdown();
} finally {
try {
//清理释放资源
cleanup();
} finally {
FastThreadLocal.removeAll();
STATE_UPDATER.set(SingleThreadEventExecutor.this, ST_TERMINATED);
threadLock.countDown();
int numUserTasks = drainTasks();
if (numUserTasks > 0 && logger.isWarnEnabled()) {
logger.warn("An event executor terminated with " +
"non-empty task queue (" + numUserTasks + ')');
}
terminationFuture.setSuccess(null);
}
}
}
}
});
}
final int drainTasks() {
int numTasks = 0;
for (;;) {
Runnable runnable = taskQueue.poll();
if (runnable == null) {
break;
}
// WAKEUP_TASK should be just discarded as these are added internally.
// The important bit is that we not have any user tasks left.
if (WAKEUP_TASK != runnable) {
numTasks++;
}
}
return numTasks;
}
//线程属性的实现类
private static final class DefaultThreadProperties implements ThreadProperties {
private final Thread t;
DefaultThreadProperties(Thread t) {
this.t = t;
}
@Override
public State state() {
return t.getState();
}
@Override
public int priority() {
return t.getPriority();
}
@Override
public boolean isInterrupted() {
return t.isInterrupted();
}
@Override
public boolean isDaemon() {
return t.isDaemon();
}
@Override
public String name() {
return t.getName();
}
@Override
public long id() {
return t.getId();
}
@Override
public StackTraceElement[] stackTrace() {
return t.getStackTrace();
}
@Override
public boolean isAlive() {
return t.isAlive();
}
}
}
1319
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
