Netty源码 reactor 模型

翻阅源码时，我们会发现netty中很多方法的调用都是通过线程池的方式进行异步的调用，

这种  eventLoop.execute 方式的调用，实际上便是reactor线程。对应项目中使用广泛的NioEventLoop。还记得我们创建的两个reactor线程池么，具体代码可以参考 Netty源码 服务端的启动

首先来解释下什么事 reactor 线程

Reactor模式是处理并发I/O比较常见的一种模式，用于同步I/O，中心思想是将所有要处理的I/O事件注册到一个中心I/O多路复用器上，同时主线程/进程阻塞在多路复用器上；
一旦有I/O事件到来或是准备就绪(文件描述符或socket可读、写)，多路复用器返回并将事先注册的相应I/O事件分发到对应的处理器中。

reactor线程的启动

---

io.netty.util.concurrent.SingleThreadEventExecutor#execute

reactor模型在第一次接受任务的时候，会启动线程

外部线程在提交任务时，netty会判断是否是当前前程是否是 SingleThreadEventExecutor中的Thread一致，如果不一致，说明需要启动一个新的线程接受任务。然后就会调用内部线程池执行reactor模型的run方法

然后就会执行addTask将线程封装成一个任务放到Queue中。Queue中的任务就是通过reactor线程来消费的。

reactor线程的执行

---

reactor线程做了三件事

1.不断的轮训注册到selector上channel的IO事件

2.处理IO事件，读取channel中的事件，选择一个work线程，准备执行任务

3.执行任务

上述三件事不断的轮训，下面我们依次进行分析。

1.select轮训

select轮训很简单，分为以下几步

1.延迟任务队列0.5秒以内有任务则中断

2.普通任务队列有任务添加则中断

3.阻塞select操作结束之后，netty又做了一系列的状态判断来决定是否中断本次轮询，中断本次轮询的条件有

• 轮询到IO事件 （selectedKeys != 0）
• oldWakenUp 参数为true
• 任务队列里面有任务（hasTasks）
• 第一个定时任务即将要被执行 （hasScheduledTasks（））
• 用户主动唤醒（wakenUp.get()）

4.解决jdk空轮训bug，具体的bug我们可以看 https://www.jianshu.com/p/3ec120ca46b2

netty这边会记录每次轮训的时间，如果轮训的时间有效，累加器会加1，累加器到256之后，开始rebuildSelector，rebuildSelector的操作其实很简单：new一个新的selector，将之前注册到老的selector上的的channel重新转移到新的selector上

Select步骤结束，表示轮训到了io事件，那么接下来我们就要去处理这些事件

2.处理IO事件

这里出现了一个selectedKeys，selectedKeys的类型是SelectedSelectionKeySet，其实也就是一个Set集合

private SelectedSelectionKeySet selectedKeys;

这里的SelectionKey又是什么呢，我们可以看下类注释

A selection key is created each time a channel is registered with a selector

每一个channel在向selector注册时都会创建一个SelectionKey。

暂且我们先认为 SelectionKey里面包含了通道注册时的一些信息。

现在我们开始处理io事件

private void processSelectedKeysOptimized(SelectionKey[] selectedKeys) {
     for (int i = 0;; i ++) {
         // 1.取出IO事件以及对应的channel
         final SelectionKey k = selectedKeys[i];
         if (k == null) {
             break;
         }
         selectedKeys[i] = null;
         final Object a = k.attachment();
         // 2.处理该channel
         if (a instanceof AbstractNioChannel) {
             processSelectedKey(k, (AbstractNioChannel) a);
         } else {
             NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;
             processSelectedKey(k, task);
         }
         // 3.判断是否该再来次轮询
         if (needsToSelectAgain) {
             for (;;) {
                 i++;
                 if (selectedKeys[i] == null) {
                     break;
                 }
                 selectedKeys[i] = null;
             }
             selectAgain();
             selectedKeys = this.selectedKeys.flip();
             i = -1;
         }
     }
 }

这里的k.attachment()能转换成AbstractNioChannel。

搜一下k.attach的调用关系，在io.netty.channel.nio.AbstractNioChannel#doRegister发现了如下代码，这能解释了selectionKey的创建

selectionKey = javaChannel().register(eventLoop().selector, 0, this);

public final SelectionKey register(Selector sel, int ops,
                                       Object att)
        throws ClosedChannelException
    {
        synchronized (regLock) {
            if (!isOpen())
                throw new ClosedChannelException();
            if ((ops & ~validOps()) != 0)
                throw new IllegalArgumentException();
            if (blocking)
                throw new IllegalBlockingModeException();
            SelectionKey k = findKey(sel);
            if (k != null) {
                k.interestOps(ops);
                k.attach(att);
            }
            if (k == null) {
                // New registration
                synchronized (keyLock) {
                    if (!isOpen())
                        throw new ClosedChannelException();
                    k = ((AbstractSelector)sel).register(this, ops, att);
                    addKey(k);
                }
            }
            return k;
        }

我们现在再来看processSelectedKey方法，代码精简后实际上就是调用unsafe对不同的事件进行处理

3.处理任务队列

netty中总共有三种任务类型

1.普通的eventLoop任务

channel.eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                //task....
            }
        });

execute并没有真正去执行，而是将任务进行了封装。

public void execute(Runnable task) {
        if (task == null) {
            throw new NullPointerException("task");
        }

        boolean inEventLoop = inEventLoop();
        if (inEventLoop) {
            addTask(task);
        } else {
            startThread();
            addTask(task);
            if (isShutdown() && removeTask(task)) {
                reject();
            }
        }

        if (!addTaskWakesUp && wakesUpForTask(task)) {
            wakeup(inEventLoop);
        }
    }

最终我们的任务添加到了一个任务队列中

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();
        }
        return taskQueue.offer(task);
    }

这里 taskQueue并不是普通的任务队列，而是Mpsc队列，即多生产者单消费者队列，netty使用mpsc，方便的将外部线程的task聚集，在reactor线程内部用单线程来串行执行

protected Queue<Runnable> newTaskQueue(int maxPendingTasks) {
        // This event loop never calls takeTask()
        return PlatformDependent.newMpscQueue(maxPendingTasks);
    }

2.外部任务

服务端在接收到客户端请求时，需要选择相应的channel写数据到客户端

ctx.channel().writeAndFlush(responsePacket);

这种在用户线程中的任务最终同样会被封装到任务队列，channel的write最终代码在io.netty.channel.AbstractChannelHandlerContext#write(java.lang.Object, boolean, io.netty.channel.ChannelPromise)

private void write(Object msg, boolean flush, ChannelPromise promise) {
        AbstractChannelHandlerContext next = findContextOutbound();
        final Object m = pipeline.touch(msg, next);
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            if (flush) {
                next.invokeWriteAndFlush(m, promise);
            } else {
                next.invokeWrite(m, promise);
            }
        } else {
            AbstractWriteTask task;
            if (flush) {
                task = WriteAndFlushTask.newInstance(next, m, promise);
            }  else {
                task = WriteTask.newInstance(next, m, promise);
            }
            safeExecute(executor, task, promise, m);
        }
    }

先判断是否在eventloop线程，这里是false，最终封装成一个task，执行safeExecutor

private static void safeExecute(EventExecutor executor, Runnable runnable, ChannelPromise promise, Object msg) {
        try {
            executor.execute(runnable);
        } catch (Throwable cause) {
            try {
                promise.setFailure(cause);
            } finally {
                if (msg != null) {
                    ReferenceCountUtil.release(msg);
                }
            }
        }
    }

接下来就和第一种情况一样，添加到队列当做。

3.定时任务

第三种场景就是定时任务逻辑，类似如下

eventLoop().schedule(new Runnable() {
                            @Override
                            public void run() {

                        }, connectTimeoutMillis, TimeUnit.MILLISECONDS);

schedule的实际逻辑也是一个添加任务队列的过程

<V> ScheduledFuture<V> schedule(final ScheduledFutureTask<V> task) {
        if (inEventLoop()) {
            scheduledTaskQueue().add(task);
        } else {
            execute(new Runnable() {
                @Override
                public void run() {
                    scheduledTaskQueue().add(task);
                }
            });
        }

        return task;
    }

这里的scheduledTaskQueue是一个优先级队列，注意这里的线程安全问题，如果不是在eventloop线程提交的，那么就会把添加操作封装成一个task，这个task的任务是添加[添加定时任务]的任务，而不是添加定时任务，其实也就是第二种场景，这样，对 PriorityQueue的访问就变成单线程，即只有reactor线程

Queue<ScheduledFutureTask<?>> scheduledTaskQueue() {
    if (scheduledTaskQueue == null) {
        scheduledTaskQueue = new PriorityQueue<ScheduledFutureTask<?>>();
    }
    return scheduledTaskQueue;
}

现在再看runAllTasks方法

分为以下3步

• 从scheduledTaskQueue转移定时任务到taskQueue
• 计算本次任务循环的截止时间并执行
• 执行完成任务后的任务

代码还是相当清晰的。这里不再深入。

最后我们再来总结下，reactor模型实质上就干了三件事情，首先他会不停的检测是否有io事件发生或者 是否有任务快要发生，如果检测到了，说明他要去干活了。首先先去处理io事件，所有的io事件都是通过unsafe去处理。处理完io事件后便开始处理任务队列里面的队列。

以上关于reactor模型的研究。