玩转Netty – 从Netty3升级到Netty4

        这篇文章主要和大家分享一下，在我们基础软件升级过程中遇到的经典Netty问题。当然，官方资料也许是一个更好的补充。另外，大家如果对Netty及其Grizzly架构以及源码有疑问的，欢迎交流。后续会为大家奉献我们基于Grizzly和Netty构建的RPC框架的压测分析，希望大家能够喜欢！

　　好了，言归正传～

依赖

　　Netty团队大概从3.3.0开始，将依赖坐标从

    <dependency>
      <groupId>org.jboss.netty</groupId>
      <artifactId>netty</artifactId>
      <version>3.2.10.Final</version>
    </dependency>

　　改成了（Netty作者离开了Jboss公司） 

    <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty</artifactId>
       <version>3.3.0.Final</version>
    </dependency>

　　这样，将其替换为Netty4，只需要替换一下版本就ok了，如替换成最新稳定版本： 

     <dependency>
         <groupId>io.netty</groupId>
         <artifactId>netty-all</artifactId>
         <version>4.0.23.Final</version>
     </dependency>

　　但请注意，从4开始，Netty团队做了模块依赖的优化，像Grizzly一样，分离出很多功能独立的Package。比方说，你希望使用Netty的buffer组件，只需简单依赖这个包就好了。不过本着严谨的态度，我们还是来看下netty-all这个一揽子包里究竟都有哪些依赖，如：

　

 　　     <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-buffer</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
          </dependency>
          <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-codec</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
           </dependency>
           <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-codec-http</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-codec-socks</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-common</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-handler</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-transport</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-transport-rxtx</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-transport-sctp</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>${project.groupId}</groupId>
                <artifactId>netty-transport-udt</artifactId>
                <version>${project.version}</version>
                <scope>compile</scope>
                <optional>true</optional>
            </dependency>

　　   每个包都代表什么呢？描述如下：

　

　    通过依赖分析，最终我选择了精简依赖，如下：

　  <dependencies>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-handler</artifactId>
            <version>4.0.23.Final</version>
        </dependency>
    </dependencies>

       为什么？因为 netty-handler依赖了 netty-codec， netty-transport， netty-buffer等，所以我的依赖最终可以瘦身到只依赖这个包。顺便说一下，在版本４中，针对Linux平台做了AIO的优化实现，如：
     

　<dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>netty-transport-native-epoll</artifactId>
        <version>${project.version}</version>
        <classifier>${os.detected.classifier}</classifier>
        <scope>compile</scope>
        <optional>true</optional>
    </dependency>

       更多的细节，可以参看这里。

       Notice：Netty3和Netty4是可以共存的，其根本原因在于Netty团队为3和4分别设计了不同的基础package名（org.jboss.netty与io.netty）。就像我的工程，服务发现依赖了Curator，而它依赖了ZK，依赖了Netty3，而我的RPC部分仅仅依赖Netty4。

线程模型

　　Netty3只保证 upstream事件在IO线程里执行,但是所有的downstream事件会被调用线程处理，它可能是IO线程，也可能是用户自定义线程，这就带来了一个问题，用户需要小心地处理同步操作。除此之外，还会面临线程上下文切换的风险，设想一下，你在write的时候遇到了异常，转而触发exceptionCaught，但这是一个upstream事件，怎么办？

　　Netty4的线程模型则不存在此类问题，因为所有的操作都被保证在同一个EventLoop里的同一个Thread完成。也就是说Netty4不存在并发访问 ChannelHandler，当然这个前提是你没有给该handler打上Sharable注解。同时它也能保证 happens-before关系，所以你也没必要在 ChannelHandler声明volatile field。

　　用户可以指定自己的 EventExecutor来执行特定的 handler。通常情况下，这种EventExecutor是单线程的，当然，如果你指定了多线程的 EventExecutor或者 EventLoop，线程sticky特性会保证，除非出现 deregistration，否则其中的一个线程将一直占用。如果两个handler分别注册了不同的EventExecutor，这时就要注意线程安全问题了。

　　Netty4的线程模型还是有很多可以优化的地方，比方说目前Eventloop对channel的处理不均等问题，而这些问题都会在Netty 5里面优化掉，感兴趣的朋友可以参看官方Issues

　　

Channel状态模型

 　　先来看两幅图，第一幅图是Netty3的Channel状态模型，第二附图是Netty４优化过的模型。可以看到，channelOpen，channelBound，和channelConnected 已经被channelActive替代。channelDisconnected，channelUnbound和channelClosed 也被 channelInactive替代。

Netty 3

Netty 4

　　这里就产生了两个问题：

       其一，channelRegistered and channelUnregistered 不等价于 channelOpen and channelClosed，它是Netty4新引入的状态为了实现Channel的dynamic registration, deregistration, and re-registration。

       第二, 既然是合并，那原先针对channelOpen的方法如何迁移？简单来做，可以直接迁移到替代方法里面。

Handler

１．　ChannelPipelineFactory －－－－> 　ChannelInitializer

      这里需要注意的是，ChannelPipeline的创建方式发生了变化，原先是这么玩的，

ChannelPipeline cp = Channels.pipeline();

      现在得这么玩

ChannelPipeline cp = ch.pipeline();

     用Netty团队的话来说就是：

“Please note that you don't create a new ChannelPipeline by yourself. After observing many use cases reported so far, the Netty project team concluded that it has no benefit for a user to create his or her own pipeline implementation
or to extend the default implementation. Therefore, ChannelPipeline is not created by a user anymore. ChannelPipeline is automatically created by a Channel.”
　

　　２．　SimpleChannelHandler －－－－>　ChannelDuplexHandler
     之前是这么玩的 

 public void handleUpstream(ChannelHandlerContext ctx, ChannelEvent e)
            throws Exception
    {
        if (e instanceof ChannelStateEvent) {
            ChannelStateEvent cse = (ChannelStateEvent) e;
            switch (cse.getState()) {
                case OPEN:
                    if (Boolean.TRUE.equals(cse.getValue())) {
                        // connect
                        channelCount.incrementAndGet();
                        allChannels.add(e.getChannel());
                    }
                    else {
                        // disconnect
                        channelCount.decrementAndGet();
                        allChannels.remove(e.getChannel());
                    }
                    break;
                case BOUND:
                    break;
            }
        }

        if (e instanceof UpstreamMessageEvent) {
            UpstreamMessageEvent ume = (UpstreamMessageEvent) e;
            if (ume.getMessage() instanceof ChannelBuffer) {
                ChannelBuffer cb = (ChannelBuffer) ume.getMessage();
                int readableBytes = cb.readableBytes();
                //  compute stats here, bytes read from remote
                bytesRead.getAndAdd(readableBytes);
            }
        }
        ctx.sendUpstream(e);
    }

    public void handleDownstream(ChannelHandlerContext ctx, ChannelEvent e)
            throws Exception
    {
        if (e instanceof DownstreamMessageEvent) {
            DownstreamMessageEvent dme = (DownstreamMessageEvent) e;
            if (dme.getMessage() instanceof ChannelBuffer) {
                ChannelBuffer cb = (ChannelBuffer) dme.getMessage();
                int readableBytes = cb.readableBytes();
                // compute stats here, bytes written to remote
                bytesWritten.getAndAdd(readableBytes);
            }
        }
        ctx.sendDownstream(e);
    }

       改成ChannelDuplexHandler之后，我只需要重写read和write方法，来完成同样的功能。

其它

１. 通过下面的代码来完成Channel的限流

       ctx.channel().setReadable(false);//Before
       ctx.channel().config().setAutoRead(false);//After

 2.  TCP参数优化

　 

      // Before:
      cfg.setOption("tcpNoDelay", true);
　　　cfg.setOption("tcpNoDelay", 0);  // Runtime ClassCastException
　　　cfg.setOption("tcpNoDelays", true); // Typo in the option name - ignored silently

　　　// After:
　　　cfg.setOption(ChannelOption.TCP_NODELAY, true);
　　　cfg.setOption(ChannelOption.TCP_NODELAY, 0); // Compile error

３. 单元测试经常用到的CodecEmbedder类已经变名为EmbeddedChannel

        @Test
    　　public void testMultipleLinesStrippedDelimiters() {
        　　EmbeddedChannel ch = new EmbeddedChannel(new DelimiterBasedFrameDecoder(8192, true,
                Delimiters.lineDelimiter()));
        　　ch.writeInbound(Unpooled.copiedBuffer("TestLine\r\ng\r\n", Charset.defaultCharset()));
        　　assertEquals("TestLine", releaseLater((ByteBuf) ch.readInbound()).toString(Charset.defaultCharset()));
        　　assertEquals("g", releaseLater((ByteBuf) ch.readInbound()).toString(Charset.defaultCharset()));
        　　assertNull(ch.readInbound());
        　　ch.finish();
   　　 }

４. 简化的关闭操作，以前我是这么玩stop的

 if (serverChannel != null) {
            log.info("stopping transport {}:{}",getName(), port);
            // first stop accepting
            final CountDownLatch latch = new CountDownLatch(1);
            serverChannel.close().addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    // stop and process remaining in-flight invocations
                    if (def.getExecutor() instanceof ExecutorService) {
                        ExecutorService exe = (ExecutorService) getExecutor();
                        ShutdownUtil.shutdownExecutor(exe, "dispatcher");
                    }
                    latch.countDown();
                }
            });
            latch.await();
            serverChannel = null;
        }

        // If the channelFactory was created by us, we should also clean it up. If the
        // channelFactory was passed in by Bootstrap, then it may be shared so don't clean  it up.
        if (channelFactory != null) {
            ShutdownUtil.shutdownChannelFactory(channelFactory, bossExecutor, ioWorkerExecutor,allChannels);
            }
}

      现在我得这么玩

 public void stop() throws InterruptedException {
        // Shut down all event loops to terminate all threads.
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();

        // Wait until all threads are terminated.
        bossGroup.terminationFuture().sync();
        workerGroup.terminationFuture().sync();
    }

５. 编解码命名改变

FrameDecoder －－－－> ByteToMessageDecoder
OneToOneEncoder  －－－－> MessageToMessageEncoder 
OneToOneDecoder －－－－> MessageToMessageDecoder

6. 心跳逻辑优化，之前我是这么玩的

　cp.addLast("idleTimeoutHandler", new IdleStateHandler(getTimer(),
                                                                          getClientIdleTimeout().toMillis(),
                                                                          NO_WRITER_IDLE_TIMEOUT,
                                                                          NO_ALL_IDLE_TIMEOUT,
                                                                          TimeUnit.MILLISECONDS));
 　cp.addLast("heartbeatHandler", new HeartbeatHandler());

      其中HeartbeatHandler 继承了IdleStateAwareChannelHandler。在Netty4里，IdleStateAwareChannelHandler已经去除，但 IdleStateHandler类还存在，所以我会这么玩 

  　cp.addLast("idleTimeoutHandler", new IdleStateHandler(
                                NO_WRITER_IDLE_TIMEOUT, NO_WRITER_IDLE_TIMEOUT,
                                NO_ALL_IDLE_TIMEOUT, TimeUnit.MILLISECONDS));

　　cp.addLast("heartbeatHandler", new HeartbeatHandler());

       其中，HeartbeatHandler 继承了ChannelInboundHandlerAdapter。具体的实现逻辑这里就不贴出来了。再啰嗦几句，很多同学喜欢自己启线程去做心跳逻辑，我是不推荐这种方式的。利用Netty的链路空闲检测机制可以很好的完成这个功能，能更好地配合Netty线程模型和异常捕获机制。自己定制，处理不好，会带来很大的线上隐患。

小结

       这篇文章简单记录了升级过程中遇到的一些比较higher的话题，配上代码，希望能更好的重现整个升级思路和过程，也希望能给大家带来帮助。如果你在升级过程中遇到了问题，欢迎留言交流。最后，祝玩的开心～

参考文档

1. http://www.infoq.com/news/2013/11/netty4-twitter
2. http://netty.io/wiki/all-documents.html
3. http://netty.io/wiki/index.html

时间： 2024-10-03 10:06:38

玩转Netty – 从Netty3升级到Netty4的相关文章

vaio升级win10会出错吗

  vaio升级win10会有bug吗?win10免费升级政策确实打动了大多数用户,大家纷纷选择在第一时间内进行升级.不过索尼近日却因为驱动问题向vaio电脑用户发出了警告,告诉他们暂时不要升级win10.   此刻VAIO用户的内心应该是崩溃的:为什么不带我们玩?索尼表示这次暂缓升级的原因来自设备驱动问题.受到波及的设备暂时划定为预装Windows 8/8.1的VAIO产品.目前还没有关于预装Windows 7的VAIO电脑升级的具体安排. VAIO用户也不要过于担心,因为索尼会在10月推出详

vaio升级win10会有bug吗？

  win10免费升级政策确实打动了大多数用户,大家纷纷选择在第一时间内进行升级.不过索尼近日却因为驱动问题向vaio电脑用户发出了警告,告诉他们暂时不要升级win10. 此刻VAIO用户的内心应该是崩溃的:为什么不带我们玩?索尼表示这次暂缓升级的原因来自设备驱动问题.受到波及的设备暂时划定为预装Windows 8/8.1的VAIO产品.目前还没有关于预装Windows 7的VAIO电脑升级的具体安排. VAIO用户也不要过于担心,因为索尼会在10月推出详细的升级说明.相关的驱动程序以及应用程序

Netty-Mina深入学习与对比（一）

感谢支付宝同事[易鸿伟]在本站发布此文. 这博文的系列主要是为了更好的了解一个完整的nio框架的编程细节以及演进过程,我选了同父(Trustin Lee)的两个框架netty与mina做对比.版本涉及了netty3.x.netty4.x.mina1.x.mina2.x.mina3.x.这里并没有写netty5.x的细节,看了netty5的修改文档,似乎有一些比较有意思的改动,准备单独写一篇netty4.x与netty5.x的不同. netty从twitter发布的这篇<Netty 4 at Tw

Netty-Mina深入学习与对比（二）

感谢支付宝同事[易鸿伟]在本站发布此文. 上文netty-mina深入学习与对比(一)讲了对netty-mina的线程模型以及任务调度粒度的理解,这篇则主要是讲nio编程中的注意事项,netty-mina的对这些注意事项的实现方式的差异,以及业务层会如何处理这些注意事项. 1. 数据是如何write出去的 java nio如果是non-blocking的话,在每次write(bytes[N])的时候,并不会将N字节全部write出去,每次write仅一部分(具体大小和tcp_write_buff

Apache Spark技术实战（三）利用Spark将json文件导入Cassandra &amp;SparkR的安装及使用

<一>利用Spark将json文件导入Cassandra 概要 sbt cassandra spark-cassandra-connector 实验目的 将存在于json文件中的数据导入到cassandra数据库,目前由cassandra提供的官方工具是json2sstable,由于对cassandra本身了解不多,这个我还没有尝试成功. 但想到spark sql中可以读取json文件,而spark-cassadra-connector又提供了将RDD存入到数据库的功能,我想是否可以将两者结合

Apache Spark技术实战（二）KafkaWordCount &amp;PackratParsers实例 &amp;Spark Cassandra Connector的安装和使用

<一>KafkaWordCount 概要 Spark应用开发实践性非常强,很多时候可能都会将时间花费在环境的搭建和运行上,如果有一个比较好的指导将会大大的缩短应用开发流程.Spark Streaming中涉及到和许多第三方程序的整合,源码中的例子如何真正跑起来,文档不是很多也不详细. 本篇主要讲述如何运行KafkaWordCount,这个需要涉及Kafka集群的搭建,还是说的越仔细越好. 搭建Kafka集群 步骤1:下载kafka 0.8.1及解压 wget https://www.apach

对不起！我来晚了！——《Android群英传》出版祭

对不起!我来晚了!--<Android群英传>出版祭 历时将近一年,我的第一本书终于就要出版了,虽然经历种种曲折,历经磨难,最终还是赶在八月份的尾巴上,修成正果. 首先,要向大家道歉,本来预计是在6月份上市的书,一拖再拖,直到现在才得以出版,让不少朋友一等再等,这里,向这些朋友的耐心,狠狠的点个赞. 写书之前 其实,当官杨主编第一次找我写书的时候,其实我是,是想拒绝的,我跟女朋友讲,我拒绝,因为,其实我还只是一个非常普通的开发者--但女朋友对我讲,写书,不一定是要有多么响的名声,用心去写,把自

通过 WSL在Windows下愉快的玩耍Linux

本文同步至https://waylau.com/enable-windows-subsystem-for-linux/ WSL(Windows Subsystem for Linux) 是 在Windows系统中为那些熟悉Linux用户准备的诸多子系统功能.换言之,你可以在Windows环境下来执行Linux操作,运行 Linux程序.这对于Windows.Linux双系统有需求的用户来说是个不错的功能.本文详细介绍了如何使用 WSL. WSL 简介 Bash 是 Linux/Unix 上非常流

通过WSL，你可以在Windows下愉快的玩耍Linux

WSL(Windows Subsystem for Linux) 是 在Windows系统中为那些熟悉Linux用户准备的诸多子系统功能.换言之,你可以在Windows环境下来执行Linux操作,运行 Linux程序.这对于Windows.Linux双系统有需求的用户来说是个不错的功能.本文详细介绍了如何使用 WSL. WSL 简介 Bash 是 Linux/Unix 上非常流行的命令行 Shell,它是 Ubuntu.RHEL 等 Linux 发行版以及苹果 OS X 操作系统默认的命令行 S