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处理，这就也就保证了线程安全。