netty 耗时任务如何处理

netty 处理耗时的任务逻辑，是不能在IO线程处理，因为这会造成堵塞，将会严重影响性能。那怎么区分IO线程呢?
答案就是EventLoop，EventLoop用来处理IO线程，因此耗时任务的handler不要在EventLoop里面处理。
以下面代码为例：

 bossGroup = new NioEventLoopGroup();
 workerGroup = new NioEventLoopGroup();

 try {
    ServerBootstrap bootstrap = new ServerBootstrap();
    bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
 ....

其中workerGroup就是专门用来处理IO线程业务逻辑的，例如执行一些 编码、解码 等不耗时的业务处理。

如果有处理耗时任务的handler应该怎么办？
可以专门开一个线程池，来专门处理耗时业务。Netty Api 已经提供了一些说明，http://netty.io/4.1/api/index...，ChannelPipeline中 可以找到如下描述：

A user is supposed to have one or more ChannelHandlers in a pipeline to receive I/O events (e.g. read) and to request I/O operations (e.g. write and close). For example, a typical server will have the following handlers in each channel's pipeline, but your mileage may vary depending on the complexity and characteristics of the protocol and business logic:

Protocol Decoder - translates binary data (e.g. ByteBuf) into a Java object.
Protocol Encoder - translates a Java object into binary data.
Business Logic Handler - performs the actual business logic (e.g. database access).
and it could be represented as shown in the following example:
static final EventExecutorGroup group = new DefaultEventExecutorGroup(16);
...

ChannelPipeline pipeline = ch.pipeline();

 pipeline.addLast("decoder", new MyProtocolDecoder());

 pipeline.addLast("encoder", new MyProtocolEncoder());

 // Tell the pipeline to run MyBusinessLogicHandler's event handler methods
 // in a different thread than an I/O thread so that the I/O thread is not blocked by
 // a time-consuming task.
 // If your business logic is fully asynchronous or finished very quickly, you don't
 // need to specify a group.
 pipeline.addLast(group, "handler", new MyBusinessLogicHandler());

其中EventExecutorGroup 就是专门来处理耗时业务的线程池。

在实际生产环境中，我们可能会碰到 需要临时执行也行计划任务，，这些任务如果不耗时，我们可以通过channel提供的计划任务方法处理：

future =  channel.eventLoop.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                            //逻辑代码，非耗时任务
               }
        }, 6, 6, TimeUnit.HOURS);
       ....

如果计划任务里面的逻辑比较耗时，那么就不能再用eventLoop，因为这会阻塞IO线程。如果是通过pipeline.addLast(group, "handler", new MyBusinessLogicHandler()); 这种方式添加的业务线程我们可以使用下面的方式添加计划任务方法实现：

***future = ctx.executor().scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
            }
        }, 6, 6, TimeUnit.HOURS);***

...

netty 源码

public EventExecutor executor() {
        return (EventExecutor)(this.executor == null？this.channel().eventLoop():this.executor);
    }

如果this.executor为null，就返回channel().eventLoop()，这个是io读写线程,肯定是不能执行耗时任务的。
如果不为空，那么是怎么传进来的呢?

DefaultChannelPipeline

public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
        final AbstractChannelHandlerContext newCtx;
        synchronized(this) {
            checkMultiplicity(handler);
            newCtx = this.newContext(group, this.filterName(name, handler), handler);

DefaultChannelPipeline 的addLast(EventExecutorGroup group, String name, ChannelHandler handler)为例，该方法部分源码如下

    @Override
    public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
        final AbstractChannelHandlerContext newCtx;
        synchronized (this) {
            checkMultiplicity(handler);

            newCtx = newContext(group, filterName(name, handler), handler);

            addLast0(newCtx);
   ...代码略去...

private AbstractChannelHandlerContext newContext(EventExecutorGroup group, String name, ChannelHandler handler) {
        return new DefaultChannelHandlerContext(this, this.childExecutor(group), name, handler);
    }

通过源码发现：其实就是我们在添加handler时指定的DefaultEventExecutorGroup。
、所以结论是：如果在处理耗时任务的Handler添加时用到了DefaultEventExecutorGroup是可以 ctx.executor().scheduleAtFixedRate这么用的，但是如果你再添加handler时没有没有指定特殊的EventExecutorGroup，是不能执行耗时任务的。

如果是在IO线程，如果想处理耗时任务逻辑，那么就需要新建一个EventExecutorGroup,并调用他的相关方法

---

EventLoop:其本质是一个用来处理IO事件的线程，EventLoopGroup 其本质是一个线程池。一个EventLoop可以和多个Channel绑定，处理多个Channel的IO事件；但是一个Channel在整个生命周期内只会被一个EventLoop处理，这就也就保证了线程安全。