Netty-性能优化

• 共享 handler--处理器修改为单例模式

serverBootstrap
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    protected void initChannel(NioSocketChannel ch) {
                        ch.pipeline().addLast(new XXXHander());
                    }
                });

处理器修改为单例模式（没有成员变量的处理器都可以修改为单例模式）：

// 1. 加上注解标识，表明该 handler 是可以多个 channel 共享的
@ChannelHandler.Sharable
public class xxxHandler extends SimpleChannelInboundHandler<xxxPacket> {

    // 2. 构造单例
    public static final xxxHandler INSTANCE = new xxxHandler();

    protected LoginRequestHandler() {
    }

}

 添加处理器修改为：

serverBootstrap
        .childHandler(new ChannelInitializer<NioSocketChannel>() {
            protected void initChannel(NioSocketChannel ch) {
                // ...单例模式，多个 channel 共享同一个 handler
                ch.pipeline().addLast(xxxHandler.INSTANCE);
                // ...
            }
        });

• ctx.writeAndFlush()和ctx.channel().writeAndFlush() 

在某个 inBound 类型的 handler 处理完逻辑之后，调用 ctx.writeAndFlush() 可以直接一口气把对象送到 codec 中编码，然后写出去 

在某个 inBound 类型的 handler 处理完逻辑之后，调用 ctx.channel().writeAndFlush()，对象会从最后一个 outBound 类型的 handler 开始，逐个往前进行传播，路径是要比 ctx.writeAndFlush() 要长的。 

 

• 减少阻塞线程的操作

• 方法一：把耗时的操作丢到业务线程池中去处理，就可以避免一些耗时的操作影响 Netty 的 NIO 线程，从而影响其他的 channel

ThreadPool threadPool = xxx;

protected void channelRead0(ChannelHandlerContext ctx, T packet) {
    threadPool.submit(new Runnable() {
        // 1. balabala 一些逻辑
        // 2. 数据库或者网络等一些耗时的操作
        // 3. writeAndFlush()
        // 4. balabala 其他的逻辑
    })
}

•  方法二：把耗时的操作放到通道的taskQueue任务队列中异步执行

protected void channelRead0(ChannelHandlerContext ctx, T packet) {
     ctx.channel().eventLoop().execute(new Runnable() {
         public void run() {
             //耗时操作放到这里运行
         }
     });
}

• 方法三：把耗时的操作放到通道的scheduleTaskQueue定时任务队列中异步执行

protected void channelRead0(ChannelHandlerContext ctx, T packet) {
     ctx.channel().eventLoop().schedule(new Runnable() {
         public void run() {
              //耗时操作放到这里运行
         }
     },5, TimeUnit.SECONDS);
}

• 准确统计处理时长

错误示范：

protected void channelRead0(ChannelHandlerContext ctx, T packet) {
    threadPool.submit(new Runnable() {
        long begin = System.currentTimeMillis();
        // 1. balabala 一些逻辑
        // 2. 数据库或者网络等一些耗时的操作
        // 3. writeAndFlush()
        // 4. balabala 其他的逻辑
        long time =  System.currentTimeMillis() - begin;
    })
}

因为 writeAndFlush() 方法如果在非 NIO 线程中执行，它是一个异步的操作，调用之后，其实是会立即返回的，剩下的所有的操作，都是 Netty 内部有一个任务队列异步执行的 ，因此，这里的 writeAndFlush() 执行完毕之后，并不能代表相关的逻辑，比如事件传播、编码等逻辑执行完毕，只是表示 Netty 接收了这个任务

正确示范：

protected void channelRead0(ChannelHandlerContext ctx, T packet) {
    threadPool.submit(new Runnable() {
        long begin = System.currentTimeMillis();
        // 1. balabala 一些逻辑
        // 2. 数据库或者网络等一些耗时的操作
        
        // 3. writeAndFlush
        xxx.writeAndFlush().addListener(future -> {
            if (future.isDone()) {
                // 4. balabala 其他的逻辑
                long time =  System.currentTimeMillis() - begin;
            }
        });
    })
}

writeAndFlush() 方法会返回一个 ChannelFuture 对象，我们给这个对象添加一个监听器，然后在回调方法里面，我们可以监听这个方法执行的结果，进而再执行其他逻辑，最后统计耗时，这样统计出来的耗时才是最准确的。