Netty核心原理

1. Netty介绍

1.1 原生NIO存在的问题

NIO的类库和API使用繁杂
需要具备其他额外的技能，如java多线程编程等才能编写出高质量的NIO程序
开发工作量和难度都非常大：例如客户端面临断连重连，半包读写，网络拥塞和异常流等情况的处理
JDK NIO的BUG：Epoll BUG，它会导致Selector空轮询，最终导致CPU 100%。直到JDK 1.7版本问题仍旧存在，没有被根本解决。

1.2 概述

Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络IO程序。Netty是一个基于NIO的网络编程框架，使用Netty可以帮助你快速、简单的开发出一个网络应用，相当于简化和流程化了NIO的开发过程。知名的Elasticsearch、Dubbo框架内部都采用了Netty。

Netty具备如下优点：

设计优雅，提供阻塞和非阻塞的Socket；提供灵活可扩展的事件模型；提供高度可定制的线程模型。
具备更高的性能和更大的吞吐量，使用零拷贝技术最小化不必要的内存复制
提供安全传输特性
支持多种主流协议，预置多种编解码功能，支持用户开发私有协议

2. 线程模型

2.1 传统阻塞I/O服务模型

采用阻塞IO模式获取输入的数据，每个连接都需要独立的线程完成数据的输入，业务处理和数据返回工作。

存在问题：

当并发数很大，就会创建大量的线程，占用很大的系统资源
连接创建后，如果当前线程暂时没有数据可读，该线程会阻塞在read操作

2.2 Reactor模型

Reactor模式，通过一个或多个输入同时传递给服务处理器的模式，服务端程序处理传入的多个请求，将他们同步分派到相应的处理线程，因此Reactor模式也叫Dispatcher模式。Reactor模式使用IO复用监听模式，收到事件后，分发给某个线程，这点就是网络服务器高并发处理关键。

1）单Reactor单线程

Selector是可以实现应用程序通过一个阻塞对象监听多路连接请求
Reactor对象通过Selector监控客户端请求事件，收到事件后通过Dispatch进行分发
如果是建立连接请求事件，则由Acceptor通过Accept处理连接请求，然后创建一个Handler对象处理连接完成后的后续业务处理
Handler会完成Read->业务处理->Send的完整业务流程

优点：

模型简单，没有多线程竞争通信的问题

缺点：

性能问题：只有一个线程，无法完全发挥出多核CPU的性能。Handler在处理某个连接上的业务时，整个进程无法处理其他连接事件，很容易导致性能瓶颈。
可靠性问题：线程意外终止或进入死循环，会导致整个系统通信模块不可用

2）单Reactor多线程

Reactor对象通过selector监控客户端请求事件，收到事件后，通过dispatch进行分发
如果是建立连接请求，则由Acceptor通过accept处理连接请求
如果不是连接请求，则由reactor分发调用连接相应的handler来处理
handler只负责响应事件，不做具体的业务处理，通过read读取数据后，会分发给后面的worker线程池来处理

优点：

可以充分的利用多核CPU的处理能力

缺点：

多线程数据共享和访问比较复杂，reactor处理所有的事件的监听和响应，在单线程运行，在高并发场景容易出现性能瓶颈

3）主从Reactor多线程

Reactor主线程MainReactor对象通过selector监听客户端连接事件，收到事件后，通过Acceptor处理客户端连接事件
当Acceptor处理完连接事件后，MainReactor将连接分为SubReactor
SubReactor将连接加入到自己的连接队列进行监听，并创建Handler对各种事件进行处理
当连接上有新事件发生的时候，SubReactor就会调用对应的Handler处理
Handler通过read从连接上读取请求数据，将请求数据分发给Worker线程池就绪业务处理。

优点：

MainReactor线程与SubReactor线程的数据交互简单职责明确，MainReactor线程只需要接收新连接，SubReactor线程完成后续的业务处理
MainReactor线程与SubReactor线程的数据交互简单，MainReactor线程只需要把新连接传给SubReactor线程，SubReactor线程无需返回数据
多个SubReactor线程能够应对更高的并发请求

缺点：

这种模式编程复杂度较高。

这种模式被广泛使用，包括Nginx、Memcached、Netty等。这种模式也叫做1+M+N线程模式，即使用该模式开发的服务器包含1个（或多个，1只是表示相对较少）连接建立线程+M个IO线程+N个业务处理线程。

2.3 Netty线程模型

Netty中我们使用最多的还是主从Reactor线程模型。

BossGroup中的线程专门负责和客户端建立连接
WorkerGroup中的线程负责处理连接上的读写

3 入门案例

引入依赖

<dependency>

    <groupId>io.netty</groupId>

    <artifactId>netty-all</artifactId>

    <version>4.1.72.Final</version>

</dependency>

服务端代码

public class DemoNettyServer {

    public static void main(String[] args) throws InterruptedException {

        EventLoopGroup bossGroup=new NioEventLoopGroup(1);

        //不填写线程数，默认是2*处理器线程数

        EventLoopGroup workerGroup=new NioEventLoopGroup();

        ServerBootstrap bootstrap=new ServerBootstrap();

        bootstrap.group(bossGroup,workerGroup)

                //设置服务端通道实现

                .channel(NioServerSocketChannel.class)

               //设置线程队列中等待连接个数

                .option(ChannelOption.SO_BACKLOG,128)

                //设置活跃状态，child是设置wokerGroup

                .childOption(ChannelOption.SO_KEEPALIVE,Boolean.TRUE)

                .childHandler(new ChannelInitializer<SocketChannel>() {

                    //创建一个通道初始化对象

                    @Override

                    protected void initChannel(SocketChannel socketChannel) throws Exception {

                        socketChannel.pipeline().addLast(new DemoNettyServerHandle());

                    }

                });

        //启动服务端并绑定端口，将异步改为同步

        ChannelFuture channelFuture = bootstrap.bind(9999).sync();

        System.out.println("服务端启动成功");

        //关闭通道（不是真正意义上的关闭，而是监听通道关闭状态）

        channelFuture.channel().closeFuture().sync();

        bossGroup.shutdownGracefully();

        workerGroup.shutdownGracefully();

    }

}

public class DemoNettyServerHandle implements ChannelInboundHandler {

    @Override

    public void channelRegistered(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void channelUnregistered(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void channelActive(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void channelInactive(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    /**

     * 通道读取事件

     * @param channelHandlerContext

     * @param o

     * @throws Exception

     */

    @Override

    public void channelRead(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {

        ByteBuf byteBuf=(ByteBuf)o;

        System.out.println("客户端发来消息:"+byteBuf.toString(CharsetUtil.UTF_8));

    }

    /**

     * 读取完毕事件

     * @param channelHandlerContext

     * @throws Exception

     */

    @Override

    public void channelReadComplete(ChannelHandlerContext channelHandlerContext) throws Exception {

        channelHandlerContext.writeAndFlush(Unpooled.copiedBuffer("你好，我是Netty服务端",CharsetUtil.UTF_8));

    }

    @Override

    public void userEventTriggered(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {

    }

    @Override

    public void channelWritabilityChanged(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void handlerAdded(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void handlerRemoved(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    /**

     * 异常发生事件

     * @param channelHandlerContext

     * @param throwable

     * @throws Exception

     */

    @Override

    public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable throwable) throws Exception {

        throwable.printStackTrace();

        channelHandlerContext.close();

    }

}

客户端代码

public class DemoNettyClient {

    public static void main(String[] args) throws InterruptedException {

        EventLoopGroup group=new NioEventLoopGroup();

        Bootstrap bootstrap=new Bootstrap();

        bootstrap.group(group)

                .channel(NioSocketChannel.class)

                .handler(new ChannelInitializer<SocketChannel>() {

                    @Override

                    protected void initChannel(SocketChannel socketChannel) throws Exception {

                        socketChannel.pipeline().addLast(new DemoNettyLientHandle());

                    }

                });

        ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9999).sync();

        channelFuture.channel().closeFuture().sync();

        group.shutdownGracefully();

    }

}

public class DemoNettyLientHandle implements ChannelInboundHandler {

    @Override

    public void channelRegistered(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void channelUnregistered(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    /**

     * 通道就绪事件

     * @param channelHandlerContext

     * @throws Exception

     */

    @Override

    public void channelActive(ChannelHandlerContext channelHandlerContext) throws Exception {

        channelHandlerContext.writeAndFlush(Unpooled.copiedBuffer("你好，我是客户端",CharsetUtil.UTF_8));

    }

    @Override

    public void channelInactive(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void channelRead(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {

        ByteBuf byteBuf=(ByteBuf)o;

        System.out.println("服务端发来消息:"+byteBuf.toString(CharsetUtil.UTF_8));

    }

    @Override

    public void channelReadComplete(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void userEventTriggered(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {

    }

    @Override

    public void channelWritabilityChanged(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void handlerAdded(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void handlerRemoved(ChannelHandlerContext channelHandlerContext) throws Exception {

    }

    @Override

    public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable throwable) throws Exception {

    }

}