五Netty源码分析--3Bootstrap.bind--中
五Netty源码分析--3Bootstrap.bind--中
TAG1.2.2 ServerBootstrapAcceptor(连接处理器--server接受client端连接--子channel创建)
该处过程是为serversocketchannel.pipeline添加一个初始化的handler处理器，需要实现initchannel方法，并在执行该方法时，会向ch.pipeline中添加ServerBootstrapAcceptor处理器。
//TAG1.2.1 ChannelPipeline.addLast
//pipeline中添加自定义ChannelInitializer（该channelInitializer添加入pipeline，在完成channe初始化后，自动从pipeline中移除
p.addLast(new ChannelInitializer<Channel>() {
@Override
public void initChannel(final Channel ch) {
final ChannelPipeline pipeline = ch.pipeline();
ChannelHandler handler = config.handler();
if (handler != null) {
pipeline.addLast(handler);
}
ch.eventLoop().execute(new Runnable() {
@Override
public void run() {
//TAG1.2.2 ServerBootstrapAcceptor
//为ServerSocketChannel的pipeline中添加ServerBootstrapAcceptor处理器
//该处理器用来把childChannel的属性，添加入serversocketchannel.accpet生成的socketchannel的属性中
pipeline.addLast(new ServerBootstrapAcceptor(
ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
}
});
}
});
}
pipeline中添加的handler如下：
上面自定义的handler是serverbootstrap$1，被包装成channelHandlerContext加入pipeline链中。
接下来看ServerBootstrapAcceptor处理器的主要工作：
ServerBootstrapAcceptor称作连接处理器，其实现ChannelInboundHandlerAdapter，因此能够处理inbound事件和具有inbound方法。在client端连接发送到server端时，这个处理器会接受client端的连接并处理。主要的方法是channelRead（实现接受client端的连接）
//该类为serverbootstrap的内部类
private static class ServerBootstrapAcceptor extends ChannelInboundHandlerAdapter {
private final EventLoopGroup childGroup;//用于处理IO连接后的操作，如read、write等的线程池---workergroup
private final ChannelHandler childHandler;//交给childgroup处理的，serversocket.pipeline上的handler
private final Entry<ChannelOption<?>, Object>[] childOptions;
private final Entry<AttributeKey<?>, Object>[] childAttrs;
private final Runnable enableAutoReadTask;
//构函
ServerBootstrapAcceptor(
final Channel channel, EventLoopGroup childGroup, ChannelHandler childHandler,
Entry<ChannelOption<?>, Object>[] childOptions, Entry<AttributeKey<?>, Object>[] childAttrs) {
this.childGroup = childGroup;
this.childHandler = childHandler;
this.childOptions = childOptions;
this.childAttrs = childAttrs;
enableAutoReadTask = new Runnable() {
@Override
public void run() {
channel.config().setAutoRead(true);
}
};
}
//ServerBootstrapAcceptor称作连接处理器，在client端连接发送到server端时，这个处理器会接受client端的连接并处理。主要的方法是channelRead（实现接受client端的连接）
@Override
@SuppressWarnings("unchecked")
public void channelRead(ChannelHandlerContext ctx, Object msg) {
//因为处理client连接请求，这里客户端发送的数据为NioServerChannel(这就是server端的子channel)
final Channel child = (Channel) msg;
//将serverbootstrap中的childhandler添加入新创建的子channel.pipeline中（这里是RpcServerInitializer对象）
child.pipeline().addLast(childHandler);
//设置child属性到childchannel中
setChannelOptions(child, childOptions, logger);
setAttributes(child, childAttrs);
try {
//TAG1.2.2.1 childGroup.register(child)
//childgroup是workergroup，用于处理write、read事件。register是注册childchannel到workergroup上的selector
childGroup.register(child).addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (!future.isSuccess()) {
forceClose(child, future.cause());
}
}
});
} catch (Throwable t) {
forceClose(child, t);
}
}
从上述过程看，ServerBootstrapAcceptor是个ChannelInboundHandlerAdapter类，其实现了channelRead方法，是inbound的handler处理类，会在client发来连接请求后，触发channelread方法。该方法完成如下两个工作：
1 初始化socketChannel，处理client端连接请求创建子channel（即nioSocketChannel):将child的相关属性设置
2 将childchannel注册到childgroup上的selector上。
（注意：netty的reactor线程模型，有两个线程组parentGroup和childGroup，分别用来处理accept连接、和连接后的IO处理等操作。这里的ServerBootstrapAcceptor，是在parentGroup接收到连接后，将后续操作交给当前acceptorhandler处理器，其是inbound的handler，因此会处理client发来的请求，channelRead用来对childchannel完成初始化，并注册到childGroup的selector上。）
TAG1.2.2.1 childGroup.register(child)-(注册子channel到workergroup)
详细方法见TAG1.3
TAG1.3 group().register(channel)-(注册父channel到bossgroup线程池)
该方法作用，主要是将channel（此处channel为刚刚创建出来的NioServerSocketChannel）注册到group上选出来的nioEventLoop上的selector上。
AbstractBootstrap
跟入源码
这里返回的group为设置的parentGroup（netty中用于处理channel连接的线程组）。
跟入register：
MultithreadEventLoopGroup
public ChannelFuture register(Channel channel) {
//从group中选出一个NioEventLoop，将channel注册到其selector上
return next().register(channel);
}
public EventLoop next() {
return (EventLoop) super.next();
}
//继续跟入父类
MultithreadEventExecutorGroup
public EventExecutor next() {
//chooser是NioEventLoopGroup初始化过程中，初始化的nioeventloop选择器（根据是否是2的幂选择chooser创建，该处省略）
return chooser.next();
}
//内部类chooser
private final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {
@Override
//next从group中选择一个nioeventloop
public EventExecutor next() {
return children[childIndex.getAndIncrement() & children.length - 1];
}
}
然后，跟入eventLoop.register(channel)
TAG1.3.1 eventLoop.register(channel)
group.register(channel)中，先从group中选择一个nioeventloop，然后执行nioeventloop.register
SingleThreadEventLoop
@Override
public ChannelFuture register(Channel channel) {
//注册，传入一个异步结果channelPromise（第一个参数为nioServerSocketChannel，第二个参数为当前NioEventLoop）
return register(new DefaultChannelPromise(channel, this));
}
@Override
public ChannelFuture register(final ChannelPromise promise) {
ObjectUtil.checkNotNull(promise, "promise");
//TAG1.3.1.1 unsafe.register(eventloop,promise)
//调用channel的内部底层类unsafe的register方法
promise.channel().unsafe().register(this, promise);
return promise;
}
//TAG1.3.1.1 unsafe.register(eventloop,promise)--保证在eventloop中执行register0
unsafe是在nioEventLoopGroup的初始化过程中创建的。继续跟入register
AbstractChannel.AbstractUnsafe.register() //channel内部类unsafe
@Override
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
if (eventLoop == null) {
throw new NullPointerException("eventLoop");
}
if (isRegistered()) {
promise.setFailure(new IllegalStateException("registered to an event loop already"));
return;
}
if (!isCompatible(eventLoop)) {
promise.setFailure(
new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
return;
}
/**…………………………………………………………………………………………………………绑定channel的eventloop…………………………………………………………………………………………………………………… */
AbstractChannel.this.eventLoop = eventLoop;
//TAG1.3.1.1.1 eventLoop.inEventLoop()
//判断当前线程与eventloop是否是同一线程
if (eventLoop.inEventLoop()) {
//TAG1.3.1.1.2 register0
register0(promise);
} else {
try {
//TAG1.3.1.1.3 eventLoop.execute
//如果当前线程与eventloop绑定不是同一线程，启动channel绑定的executor.execute执行register0
eventLoop.execute(new Runnable() {
@Override
public void run() {
register0(promise);
}
});
} catch (Throwable t) {
logger.warn(
"Force-closing a channel whose registration task was not accepted by an event loop: {}",
AbstractChannel.this, t);
closeForcibly();
closeFuture.setClosed();
safeSetFailure(promise, t);
}
}
}
抽取unsafe.register的核心代码部分，如下
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
//channel与eventloop的绑定
AbstractChannel.this.eventLoop = eventLoop;
/**………………………………………………………………………………………………保证从eventloop所在的线程执行register0…………………………………………………………………………………………6 */
//TAG1.3.1.1.1 eventLoop.inEventLoop()
//判断当前的线程，与eventloop所绑定的thread是否为同一个
//(eventLoop是一个executorService，它的执行需要execute一个线程，也就是创建并绑定线程)
if (eventLoop.inEventLoop()) {
//如果当前线程是eventloop所在线程发起的，则执行register0操作
//TAG1.3.1.1.2 register0
register0(promise);
} else {
//否则，执行当前绑定的eventloop的execute，新建一个runnable任务加入任务队列，并从eventloop启动新的线程
//（保证register0操作是eventloop执行）
try {
//TAG1.3.1.1.3 eventLoop.execute
//server端启动时，bossgroup中尚未启动，因此eventloop线程尚未启动，执行这里启动eventloop线程
eventLoop.execute(new OneTimeTask() {
@Override
public void run() {
register0(promise);
}
});
}
主要完成如下任务：
unsafe.register()的逻辑，因为unsafe是channel内部类，实现eventloop与channel绑定，并保证实际的register0操作，必须在eventloop所在线程中执行（如果当前线程是eventloop绑定线程，直接执行register0；如果不是，从 eventloop.execute开启线程，执行实际注册register0）。
1 实现eventloop与channel的绑定；
2 判定执行当前unsafe.register的操作是否是eventloop所在的线程，然后执行register0；
3 如果不是，创建包含register0的runnable对象，加入当前绑定的eventloop的任务队列，并开启线程执行。
针对上述核心步骤，逐个跟踪源码分析：
TAG1.3.1.1.1 eventLoop.inEventLoop()
AbstractEventExecutor
public boolean inEventLoop() {
return inEventLoop(Thread.currentThread());
}
SingleThreadEventExecutor
//该类中thread，保存nioeventloop所绑定的thread
@Override
public boolean inEventLoop(Thread thread) {
return thread == this.thread;
}
判断当前Thread.currentThread()是否是nioeventloop所绑定的thread。
TAG1.3.1.1.2 eventLoop.execute--(NioEventLoop启动)
在server端启动时，bossgroup中线程尚未开启，因此执行当前过程的thread不是group中nioeventloop所绑定的thread。因此执行此处，调用group中nioeventloop.execute()开启线程，执行注册。
SingleThreadEventExecutor
@Override
public void execute(Runnable task) {
if (task == null) {
throw new NullPointerException("task");
}
boolean inEventLoop = inEventLoop();
TAG1.3.1.1.2.1 addTask
//如果当前线程是nioeventloop所绑定thread，直接添加task任务到任务队列（task任务为register0()操作的runnable）
addTask(task);
//当前线程不是nioeventloop绑定的thread，这里启动eventloop的线程
if (!inEventLoop) { //2
TAG1.3.1.1.2.2 startThread
//创建并启动一个线程
startThread();
if (isShutdown()) { //3
boolean reject = false;
try {
//如果线程关闭，移除task任务（register0）
if (removeTask(task)) {
reject = true;
}
} catch (UnsupportedOperationException e) {
}
if (reject) {
reject();
}
}//3
} //2
if (!addTaskWakesUp && wakesUpForTask(task)) {
wakeup(inEventLoop);
}
}
在executor.execute(task)方法中，如果当前线程是eventloop中所绑定的线程，则直接添加task到任务队列；否则，重新开启线程，并添加task到任务队列。
TAG1.3.1.1.2.1 addTask
SingleThreadEventExecutor
protected void addTask(Runnable task) {
if (task == null) {
throw new NullPointerException("task");
}
if (!offerTask(task)) {
reject(task);
}
}
final boolean offerTask(Runnable task) {
if (isShutdown()) {
reject();
}
//将task添加入任务队列（任务队列，是在初始化group时，newchild时创建的）
return taskQueue.offer(task);
}
将register0包装的任务task，添加入NioEventLoop中的taskQueue任务队列中。
TAG1.3.1.1.2.2 startThread
然后跟入startExecution开启线程方法内
由于executor.execute执行，所以走这里创建并开启线程。
SingleThreadEventExecutor
//开启线程
private void startThread() {
//当前eventloop所绑定线程尚未启动时
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 void doStartThread() {
assert thread == null;
executor.execute(new Runnable() {
@Override
public void run() {
//绑定currentthread为nioeventloop的thread
thread = Thread.currentThread();
if (interrupted) {
thread.interrupt();
}
boolean success = false;
updateLastExecutionTime();
try {
//执行一个不会停止的for，完成任务队列中的任务
SingleThreadEventExecutor.this.run();
success = true;
} catch (Throwable t) {
logger.warn("Unexpected exception from an event executor: ", t);
} finally {
………………………………
}
}
});
}
StartThread1 NioEventLoop.run--(处理eventloop中添加任务或者就绪事件)
启动nioeventloop线程，并完成addTask过程所添加任务(register0)。
跟入 SingleThreadEventExecutor.this.run()方法，
实现类为NioEventLoop.run
这里开启for(;;)的无限循环，用来完成nioeventloop中taskqueue任务队列中的task（此处是register0任务）
nioeventloop
@Override
protected void run() {
for (;;) {
try {
try {
//ST1 selectStrategy.calculateStrategy
//选择就绪channel
switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
case SelectStrategy.CONTINUE: //-2 不支持
continue;
case SelectStrategy.BUSY_WAIT: //-3 不支持
//ST2 select(wakenUp.getAndSet(false))
case SelectStrategy.SELECT: //-1 执行到此处，说明taskqueue中没有任务
//selector.select是阻塞的selection过程，该wakenup用来标志该阻塞过程，是否可以跳出、终结select过程
select(wakenUp.getAndSet(false));
if (wakenUp.get()) {
selector.wakeup();
}
default: //其他情况，不处理
}
} catch (IOException e) {
// If we receive an IOException here its because the Selector is messed up. Let's rebuild
// the selector and retry. https://github.com/netty/netty/issues/8566
rebuildSelector0();
handleLoopException(e);
continue;
}
cancelledKeys = 0;
needsToSelectAgain = false;
//ST3 ioRatio
//处理就绪channel中IO操作时间/处理taskqueue中任务时间所分配的比例（如果100，表示只有IO操作，如果0，表示只执行taskqueue任务）
final int ioRatio = this.ioRatio;
//ioRatio为100，只执行channel中的IO操作
if (ioRatio == 100) {
try {
//先处理channel中就绪的IO
processSelectedKeys();
} finally {
// 保证nioeventloop永远执行taskqueue中任务
runAllTasks();
}
} else {
//不为100，需要计算IO操作执行时间与taskqueue中执行时间
final long ioStartTime = System.nanoTime();
try {
//ST4 processSelectedKeys
processSelectedKeys();
} finally {
//执行任务（根据ratio分配的时间比例）
final long ioTime = System.nanoTime() - ioStartTime;
//ST5 runAllTasks
runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
}
}
} catch (Throwable t) {
handleLoopException(t);
}
// Always handle shutdown even if the loop processing threw an exception.
try {
if (isShuttingDown()) {
closeAll();
if (confirmShutdown()) {
return;
}
}
} catch (Throwable t) {
handleLoopException(t);
}
}
}
ST1 selectStrategy.calculateStrategy
switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
首先分析该方法的两个参数：
public final class NioEventLoop extends SingleThreadEventLoop {
//这个类是个int整数的supplier提供类
private final IntSupplier selectNowSupplier = new IntSupplier() {
//get()方法获取int值
@Override
public int get() throws Exception {
//
return selectNow();
}
};
int selectNow() throws IOException {
try {
//返回当前selector上相关就绪的channels的数量。非阻塞操作（selectorNow执行会清除wakeup的效果）
return selector.selectNow();
} finally {
//nioeventloop存储wakeup标志位（true，表示可以终结selectNow的操作）
if (wakenUp.get()) {
selector.wakeup();
}
}
}
SingleThreadEventLoop
@Override
protected boolean hasTasks() {
//nioeventloop中任务队列taskqueue和收尾队列tailtask至少有一个不为null
return super.hasTasks() || !tailTasks.isEmpty();
}
SingleThreadEventExecutor
protected boolean hasTasks() {
assert inEventLoop();
return !taskQueue.isEmpty();
}
selectStrategy.calculateStrategy
final class DefaultSelectStrategy implements SelectStrategy {
static final SelectStrategy INSTANCE = new DefaultSelectStrategy();
private DefaultSelectStrategy() { }
@Override
public int calculateStrategy(IntSupplier selectSupplier, boolean hasTasks) throws Exception {
return hasTasks ? selectSupplier.get() : SelectStrategy.SELECT;
}
如果任务队列有任务，执行selectSupplier.get()
//这个类是个int整数的supplier提供类
private final IntSupplier selectNowSupplier = new IntSupplier() {
//get()方法获取int值
@Override
public int get() throws Exception {
//
return selectNow();
}
};
int selectNow() throws IOException {
try {
//返回当前selector上相关就绪的channels的数量。非阻塞操作（selectorNow执行会清除wakeup的效果）
return selector.selectNow();
} finally {
//nioeventloop存储wakeup标志位（true，表示可以终结selectNow的操作）
if (wakenUp.get()) {
selector.wakeup();
}
}
}
public abstract class Selector implements Closeable {
//非阻塞select
public abstract int selectNow() throws IOException;
//阻塞select，返回的条件：有至少一个channel就绪、selector.wakeup、当前thread被中断、给定时间内未有就绪channel，任意情况，可以返回
public abstract int select(long timeout) throws IOException;
//阻塞select，返回条件：有至少一个channel就绪、selector.wakeup、当前thread被中断，任意情况，可以返回
public abstract int select() throws IOException;
//唤醒阻塞的select操作
public abstract Selector wakeup();
从上述可知：
1 selector的选择，有非阻塞操作（selectNow)、阻塞操作（select）。selectNow立即返回当前就绪的channel数量，可以为0；select阻塞，在有至少一个channel就绪、selector.wakeup、当前thread被中断、给定时间内未有就绪channel，任意情况，可以返回。
2 selector.wakeup(),对于阻塞的select操作，可以唤醒阻塞于此处的值返回，如果此时没有就绪的channel，就返回0；
3 NioEventLoop中的wakenUp标识当前selector.select操作是否被阻塞，没有阻塞，返回true；被阻塞，返回false。
此外，selector.select方法，监控所有注册的channel，如果有IO操作可以执行时，将对应的selectionKey加入到内部集合中并返回。
因此，对于
selectSupplier.get()返回的值大于等于0；只有当hasTasks为0，即任务队列不存在任务时候，才会返回SelectStrategy.SELECT。
ST2 select(wakenUp.getAndSet(false))
switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
case SelectStrategy.CONTINUE://不支持
continue;
case SelectStrategy.BUSY_WAIT://不支持
// fall-through to SELECT since the busy-wait is not supported with NIO
case SelectStrategy.SELECT://只有当任务队列不存在任务，会执行到此处，执行阻塞式select
select(wakenUp.getAndSet(false));
//如果是阻塞select选择，那么唤醒selector
if (wakenUp.get()) {
selector.wakeup();
}
如果任务队列不存在任务，就执行一次阻塞式的select。其中，wakenUp.getAndSet(false)，设置select操作的模式为阻塞，然后执行阻塞式select。
NioEventLoop
private void select(boolean oldWakenUp) throws IOException {
Selector selector = this.selector;
try {
//selectCnt记录nioeventloop.select()中空轮训的次数，用以终止for(;;),避免CPU占用率飙升
int selectCnt = 0;
//启动for循环前的当前时间
long currentTimeNanos = System.nanoTime();
//delayNanos(currentTimeNanos)，计算当前定时任务中，最近到时的定时任务，距离执行的时间
long selectDeadLineNanos = currentTimeNanos + delayNanos(currentTimeNanos);
//计算下一次wakeup时间
long normalizedDeadlineNanos = selectDeadLineNanos - initialNanoTime();
if (nextWakeupTime != normalizedDeadlineNanos) {
nextWakeupTime = normalizedDeadlineNanos;
}
for (;;) {
//计算定时任务执行的时间
long timeoutMillis = (selectDeadLineNanos - currentTimeNanos + 500000L) / 1000000L;
if (timeoutMillis <= 0) { //定时任务时间小于0，表示有需要立即执行的定时任务
if (selectCnt == 0) { //第一次for循环，会执行selector非阻塞select
selector.selectNow();
selectCnt = 1;
}
break;
}
//在for循环中，检查任务队列中是否有新任务加入，如果有，设置wakeup标志为非阻塞，并selector.selectNow非阻塞选择
if (hasTasks() && wakenUp.compareAndSet(false, true)) {
selector.selectNow();
selectCnt = 1;
break;
}
/**…………………………………………………………………………………………………………阻塞定时任务到期时间的select(timeout)………………………………………………………………………… */
//阻塞指定时间的select
int selectedKeys = selector.select(timeoutMillis);
selectCnt ++;
//1 如果有就绪channel，oldWakenUp为true（非阻塞）、当前wakenUp.get()、有新任务、到期定时任务，跳出循环
//select()中for循环结束的条件--有就绪channel、oldWakenUp为true（非阻塞）、当前wakenUp.get()、有新任务、到期定时任务
if (selectedKeys != 0 || oldWakenUp || wakenUp.get() || hasTasks() || hasScheduledTasks()) {
break;
}
//线程中断，重置
if (Thread.interrupted()) {
if (logger.isDebugEnabled()) {
logger.debug("Selector.select() returned prematurely because " +
"Thread.currentThread().interrupt() was called. Use " +
"NioEventLoop.shutdownGracefully() to shutdown the NioEventLoop.");
}
selectCnt = 1;
break;
}
//2 在指定阻塞select(timeoutMillis)返回后，没有就绪channel，
long time = System.nanoTime();
//如果此处为true，表明前面selector.select(timeoutMillis)是指定时间后跳出，不是被wakeup唤醒或者中断select
if (time - TimeUnit.MILLISECONDS.toNanos(timeoutMillis) >= currentTimeNanos) {
// timeoutMillis elapsed without anything selected.
selectCnt = 1;
} else if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {//空轮训次数大于512时，跳出循环
// The code exists in an extra method to ensure the method is not too big to inline as this
// branch is not very likely to get hit very frequently.
selector = selectRebuildSelector(selectCnt);//重构selector（不太容易执行到这里）
selectCnt = 1;
break;
}
//当前for循环轮，结束的时间
currentTimeNanos = time;
}
if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS) {
if (logger.isDebugEnabled()) {
logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
selectCnt - 1, selector);
}
}
} catch (CancelledKeyException e) {
if (logger.isDebugEnabled()) {
logger.debug(CancelledKeyException.class.getSimpleName() + " raised by a Selector {} - JDK bug?",
selector, e);
}
// Harmless exception - log anyway
}
}
上面逻辑，是当nioeventloop中任务队列中没有任务的处理逻辑，执行阻塞的select，方法内有for(;;)的空轮训，当有就绪的channel（selector.select不为0）、或者有新添加的任务时，会跳出阻塞nioeventloop.select的for轮询过程，再执行后续的操作--处理就绪channel或者新添加如任务队列的任务。
ST3 ioRatio
ioRatio的比例，是处理就绪channel中IO操作时间/处理taskqueue中任务时间所分配的比例（如果100，表示只有IO操作，如果0，表示只执行taskqueue任务），且ioRatio是个整数，如果ioRatio为20，表示在执行时间分配中，channel的执行时间为20%；处理任务队列的时间分配为80%。
计算逻辑的源码如下：
//ST3 ioRatio
//处理就绪channel中IO操作时间/处理taskqueue中任务时间所分配的比例（如果100，表示只有IO操作，如果0，表示只执行taskqueue任务）
final int ioRatio = this.ioRatio;
//ioRatio为100，只执行channel中的IO操作
if (ioRatio == 100) {
try {
//先处理channel中就绪的IO
processSelectedKeys();
} finally {
// 保证nioeventloop永远执行taskqueue中任务
runAllTasks();
}
} else {
//不为100，需要计算IO操作执行时间与taskqueue中执行时间
final long ioStartTime = System.nanoTime();
try {
//ST4 processSelectedKeys
processSelectedKeys();
} finally {
//执行任务（根据ratio分配的时间比例）
final long ioTime = System.nanoTime() - ioStartTime;
//ST5 runAllTasks
runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
}
}
} catch (Throwable t) {
handleLoopException(t);
}
ST4 processSelectedKeys
处理selector上就绪的channel。
NioEventLooop
private void processSelectedKeys() {
if (selectedKeys != null) {
//ST4.1 processSelectedKeysOptimized
//channel的selectedkeys优化过的，处理优化过的key------优化，只是将selectedKeys由set转换为数组
processSelectedKeysOptimized();
} else {
//处理普通的selectedKeys
processSelectedKeysPlain(selector.selectedKeys());
}
}
根据对selector.selectedKeys()所返回的set
//ST4.1 processSelectedKeysOptimized
NioEventLoop
private void processSelectedKeysOptimized() {
for (int i = 0; i < selectedKeys.size; ++i) {
final SelectionKey k = selectedKeys.keys[i];
//设置当前key为null，一旦channel关闭，可以回收该SelectionKey
selectedKeys.keys[i] = null;
//获取SelectionKey中存放的attachment，可以存入任何类型内容（此处存放NIO的channel）
final Object a = k.attachment();
//判断a是否是NioServerSocketChannel/NioSocketChannel
if (a instanceof AbstractNioChannel) {
//ST4.1.1 processSelectedKey(k, (AbstractNioChannel) a)
//处理就绪selectionKey
processSelectedKey(k, (AbstractNioChannel) a);
} else {
//测试类实现方法
@SuppressWarnings("unchecked")
NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;
processSelectedKey(k, task);
}
if (needsToSelectAgain) {
// null out entries in the array to allow to have it GC'ed once the Channel close
// See https://github.com/netty/netty/issues/2363
selectedKeys.reset(i + 1);
selectAgain();
i = -1;
}
}
}
这里逻辑，是从selectedKeys中轮询处理，取出每个就绪的key，然后设置selectedKeys中对应的key为null，方便channel关闭时，能够被gc回收。然后处理就绪selectionkey
//ST4.1.1 processSelectedKey(k, (AbstractNioChannel) a)
处理就绪selectionkey
NioEventLoop
private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
//获取Netty的channel中unsafe工具类
final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
//ST4.1.1.1 selectionKey.isValid
//判断当前selectionkey是否有效
if (!k.isValid()) {
final EventLoop eventLoop;
try {
eventLoop = ch.eventLoop();
} catch (Throwable ignored) {
return;
}
if (eventLoop != this || eventLoop == null) {
return;
}
//如果selectionkey无效，则关闭资源
unsafe.close(unsafe.voidPromise());
return;
}
/**…………………………………………………………………………selectionKey中readOps和interestOps的处理…………………………………………………………………………………… */
try {
int readyOps = k.readyOps(); //获取就绪k的ops
/**………………………………………………………………………………………………CONNECT处理………………………………………………………………………………………………………………………… */
//ST4.1.1.2 CONNECT处理
//位运算，判断当前就绪k的关注事件，包含CONNECT操作
if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
int ops = k.interestOps();
//为当前interestOps删除掉CONNECT操作
ops &= ~SelectionKey.OP_CONNECT;
k.interestOps(ops);
//连接server
unsafe.finishConnect();
}
/**………………………………………………………………………………………………WRITE处理………………………………………………………………………………………………………………………… */
//ST4.1.1.3 WRITE处理
// 处理写就绪情况
if ((readyOps & SelectionKey.OP_WRITE) != 0) {
// 强制flush，将buffer缓存中内容写入网络网关中
ch.unsafe().forceFlush();
}
/**………………………………………………………………………………………………READ、ACCEPT处理………………………………………………………………………………………………………………………… */
//ST4.1.1.4 READ、ACCEPT处理
//处理read就绪或者accept的操作（accept是serversocketchannel关注的事件），或者没有任何channel就绪的
if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
//将网络网卡中数据，read读入buffer中
unsafe.read();
}
} catch (CancelledKeyException ignored) {
unsafe.close(unsafe.voidPromise());
}
}
processSelectedKey逻辑：
//ST4.1.1.1 selectionKey.isValid
//ST4.1.1.2 CONNECT处理
//ST4.1.1.3 WRITE处理
//ST4.1.1.4 READ、ACCEPT处理
//ST4.1.1.1 selectionKey.isValid
判断selectionkey是否有效，取决于selectableChannel.register(selector,ops)时，注册在当前channel上的事件是否有效。serverSocketChannel只关注ACCEPT事件；socketchannel关注CONNECT、READ、WRITE事件。
//ST4.1.1.2 CONNECT处理
在这里，将readyOps的关注位处理，并添加到k中原理
/**………………………………………………………………………………………………CONNECT处理………………………………………………………………………………………………………………………… */
//ST4.1.1.2 CONNECT处理
//位运算，判断当前就绪k的关注事件，包含CONNECT操作
if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
int ops = k.interestOps();
//为当前interestOps删除掉CONNECT操作
ops &= ~SelectionKey.OP_CONNECT;
k.interestOps(ops);
//连接server
unsafe.finishConnect();
}
在selectionKey中，有两个参数readyOps、interestOps（这些参数的add与判断，都是通过位运算实现的---取反、异或、非等处理）
SelectionKey
interestOps;// selectionkey创建时进行初始化的参数，表示在selector上注册的感兴趣的操作；
readyOps;// 上面interestOps的子集，表示已经准备好进行处理的channel
对于connect的类型，如果readyops包含CONNECT操作，此时需要从selectionkey的关注的操作位interestOps上删除掉CONNECT的操作（删除CONNECT后，剩余的操作可能为READ、WRITE等，然后重新添加入selectionkey的关注事件操作位中）。
CONNECT事件，只有client端channel会关注，server端不关注。因此一旦connect，就删除此操作位。
//ST4.1.1.3 WRITE处理
//ST4.1.1.4 READ、ACCEPT处理
ST5 runAllTasks
拉取任务队列中的task任务，并执行。
SingleThreadEventExecutor
//在指定timeoutNanos的时间内执行任务队列的任务
protected boolean runAllTasks(long timeoutNanos) {
//ST5.1 fetchFromScheduledTaskQueue
//从NioEventLoop中的定时任务队列scheduledQueue中拉取到期任务，并添加入TaskQueue
fetchFromScheduledTaskQueue();
//ST5.2 pollTask 拉取任务队列中队列
Runnable task = pollTask();
if (task == null) {
//如果任务队列中没有任务，执行收尾队列中任务
afterRunningAllTasks();
return false;
}
final long deadline = ScheduledFutureTask.nanoTime() + timeoutNanos;
long runTasks = 0;
long lastExecutionTime;
//for轮询
for (;;) { //2
//ST5.3 safeExecute(task)
safeExecute(task);
runTasks ++;
// 由于nanoTime()方法消耗大，因此每64次执行一次到期时间检查
if ((runTasks & 0x3F) == 0) {
lastExecutionTime = ScheduledFutureTask.nanoTime();
//到期时间检查
if (lastExecutionTime >= deadline) {
break;
}
}
task = pollTask();
if (task == null) {
lastExecutionTime = ScheduledFutureTask.nanoTime();
break;
}
} //2
//ST5.3 afterRunningAllTasks处理tailtask收尾队列中任务
afterRunningAllTasks();
this.lastExecutionTime = lastExecutionTime;
return true;
}
//ST5.1 fetchFromScheduledTaskQueue
SingleThreadEventExecutor
private boolean fetchFromScheduledTaskQueue() {
if (scheduledTaskQueue == null || scheduledTaskQueue.isEmpty()) {
return true;
}
long nanoTime = AbstractScheduledEventExecutor.nanoTime();
for (;;) {
//获取在nanoTime到期的定时任务
Runnable scheduledTask = pollScheduledTask(nanoTime);
if (scheduledTask == null) {
return true;
}
//尝试将到期的定时任务scheduledTask加入taskQueue任务队列
if (!taskQueue.offer(scheduledTask)) {
scheduledTaskQueue.add((ScheduledFutureTask<?>) scheduledTask);
return false;
}
}
}
从定时任务队列中获取即将到期的定时任务，加入taskQueue中。
//ST5.2 pollTask
NioEventLoop
@Override
protected Runnable pollTask() {
Runnable task = super.pollTask();
if (needsToSelectAgain) {
selectAgain();
}
return task;
}
SingleThreadEventExecutor
protected Runnable pollTask() {
assert inEventLoop();
return pollTaskFrom(taskQueue);
}
protected static Runnable pollTaskFrom(Queue<Runnable> taskQueue) {
for (;;) {
Runnable task = taskQueue.poll();
if (task != WAKEUP_TASK) {
return task;
}
}
}
//ST5.3 safeExecute(task)
AbstractEventExecutor
protected static void safeExecute(Runnable task) {
try {
task.run(); //然后执行TAG1.3.1.1.3 register0方法流程
} catch (Throwable t) {
logger.warn("A task raised an exception. Task: {}", task, t);
}
}
浙公网安备 33010602011771号