二、netty核心功能与线程模型

qinzhongliang
315 阅读9分钟

一、Netty初探

1、Netty快速入门

概念： Netty是业界最流行的NIO框架，整合了多种协议(FTP、SMTP、HTTP等各种二进制文本协议)的实现经验而精心设计的框架，在多个大型商业项目中得到了充分的验证。

为什么选择Netty： Netty是业界最流行的NIO框架之一，它的健壮性、功能、性能、可定制性和可扩展性在同类框架中都是首屈一指的，它已经得到成百上千的商用项目验证。

2、Netty优点

  • API使用简单，开发门槛低
  • 功能强大，预置了多种编解码功能，支持多种主流协议
  • 定制能力强，可以通过ChannelHandler对通信框架进行灵活的扩展
  • 性能高，通过与其它业界主流的NIO框架对比，Netty的综合性能最优
  • 社区活跃，版本迭代周期短，发现的bug可以被及时修复，同时也会加入更多的新功能
  • 经历了大规模的商业应用考验，质量得到验证

二、Netty的使用场景

1、互联网行业

在分布式系统中，各个节点之间需要远程服务调用，高性能的RPC框架必不可少，Netty作为异步高性能的通信框架，往往作为基础通信组件被这些RPC框架使用。典型的应用有阿里的分布式服务框架Dubbo(RPC框架)，使用Dubbo协议进行节点间通信，Dubbo协议默认使用Netty作为基础通信组件，用于实现各进程节点之间的内部通信。Rocketmq底层也是用的Netty作为基础通信组件。

2、游戏行业

无论是手游服务端、还是大型的网络游戏，Java语言得到了越来越广泛的应用。Netty作为高性能的基础通信组件，它本身提供了TCP和UDP以及HTTP等协议栈，非常方便定制和开发私有协议栈

3、大数据领域

经典的Hadoop的高性能通信和序列化组件Avro(RPC框架)，默认采用Netty进行跨节点通信，它的Netty Service是基于Netty框架二次封装的实现。

4、通信行业

Netty的异步高性能、高可靠性和高成熟度的优点，使它在通信行业得到了大量的应用。

三、Netty线程模型

可以先理解下Scalable IO in Java这篇文章里说的一些IO处理模式，Netty的线程模型如下图所示：

模型解释如下：

  • Netty抽象出两个线程池BossGroup和WorkerGroup，BossGroup专门负责接收客户端的连接，WorkerGroup专门负责网络的读写，BossGroup和WorkerGroup类型都是NioEventLoopGroup，NioEventLoopGroup相当于一个事件循环线程组，NioEventLoopGroup中含有多个事件循环线程(NioEventLoop)，每个NioEventLoop都有一个selector，用于监听注册在其上的socketChannel通道
  • 每个BossGroup中NioEventLoop线程内部循环执行的步骤有3步：
    • 处理accept事件，与client建立连接，生成NioSocketChannel
    • 将NioSocketChannel注册到某个WorkerGroup中的NioEventLoop上的selector
    • 处理任务队列的任务，即runAllTasks
  • 每个WorkerGroup中NIOEventLoop线程内部循环执行的步骤有3步：
    • 轮询注册到自己selector上的所有NioSocketChannel的read、write事件
    • 处理I/O事件，即read、write事件，在对应NioSocketChannel上处理业务
    • runAllTasks处理任务队列TaskQueue中的任务，一些耗时的业务处理一般可以放入TaskQueue中慢慢处理，这样不影响数据在pipeline中的流动处理
  • 每个WorkerGroup中的NioEventLoop处理NioSocketChannel业务时，会使用pipeline(管道)，管道中维护了很多handler处理器用来处理channel中的数据

四、Netty模块组件

1、EventLoopGroup接口

NioEventLoopGroup主要管理EventLoop的生命周期，可以理解为一个线程池，内部维护了一组线程，每个线程(NioEventLoop)负责处理多个Channel上的事件，而一个Channel只对应于一个线程。

2、EventLoop接口

EventLoop中维护了一个线程和一个任务队列，线程启动时会调用NioEventLoop的run方法，执行I/O任务和非I/O任务。

I/O任务即selectionKey中ready的事件，如accept、connect、read、write等，由processSelectedKeys方法触发。

非IO任务即添加到taskQueue中的任务，如register0、bind0等任务，由runAllTasks方法触发。

3、ServerBootstrap与Bootstrap

Bootstrap意思是引导，一个Netty应用通常由一个Bootstrap开始，主要作用是配置整个Netty程序，串联各个组件，Netty中Bootstrap类是客户端程序的启动引导类，ServerBootstrap是服务端启动引导类。

4、Channel

Netty网络通信的组件，客户端与服务端建立的一个连接通道，能够用于执行网络I/O操作。不同协议、不同的阻塞类型的连接都有不同的Channel类型与之对应。

5、ChannelHandler

ChannelHandler是一个接口，负责处理I/O事件或拦截I/O操作，并将其转发到其ChannelPipeline(业务处理链)中的下一个处理程序。

6、ChannelHandlerContext

ChannelHandlerContext用于保存Channel相关的所有上下文信息，同时关联一个ChannelHandler对象。

7、ChannelPipline

ChannelPipline负责管理ChannelHandler的有序容器，用于处理或拦截Channel的入站事件和出站操作。

在Netty中每个Channel都有且仅有一个ChannelPipeline与之对应，它们的组成关系如下：

一个Channel包含了一个ChannelPipeline，所有ChannelHandler都会顺序加入到ChannelPipeline中，创建Channel时会自动创建一个ChannelPipeline，每个Channel都有一个管理它的ChannelPipeline，而ChannelPipeline中又维护了一个由ChannelHandlerContext组成的双向链表，并且每个ChannelHandlerContext中又关联着一个ChannelHandler。

read事件(入站事件)和write事件(出站事件)在一个双向链表中，入站事件会从链表head往后传递到最后一个入站的handler，出站事件会从链表tail往前传递到最前一个出站的handler，两种类型的handler互不干扰。

8、Future与ChannelFuture

在Netty中所有的IO操作都是异步的，这意味着任何I/O调用都会立即返回，而ChannelFutures会提供有关的I/O操作结果或状态。

9、Selector

Netty是基于Selector对象实现I/O多路复用的，通过Selector一个线程可以监听多个连接的Channel事件。当向一个Selector中注册Channel后，Selector内部的机制就会自动不断地查询注册到Select上的Channel是否有已就绪的I/O事件(例如可读，可写，网络连接完成等)，这样程序就可以很简单地使用一个线程高效地管理多个Channel。

五、Netty入门通讯示例

1、服务端代码

public class NettyServer {

    public static final Logger LOGGER = LoggerFactory.getLogger(NettyServer.class);

    public static void main(String[] args) {
        //todo 创建bossGroup线程组，负责处理连接请求，含有子线程NioEventLoop的个数默认为cpu核数的两倍
        EventLoopGroup bossGroup = new NioEventLoopGroup(10);
        //todo 创建workerGroup线程组，负责处理业务请求，含有子线程NioEventLoop的个数默认为cpu核数的两倍
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //todo 创建服务器端的启动对象
            ServerBootstrap bootstrap = new ServerBootstrap();
            //todo 设置两个线程组
            bootstrap.group(bossGroup, workerGroup)
                    //todo 使用NioServerSocketChannel作为服务器的通道实现
                    .channel(NioServerSocketChannel.class)
                    //todo 初始化服务器连接队列大小，服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    //todo 创建通道初始化对象，设置初始化参数
                    .childHandler(new ChannelInitializer<SocketChannel>() {//todo 创建通道初始化对象，设置初始化参数
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //todo 对workerGroup的SocketChannel设置处理器
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    });
            LOGGER.info("netty server start ...");
            //todo 启动服务器并绑定端口，bind是异步操作，sync方法是等待异步操作执行完毕
            ChannelFuture cf = bootstrap.bind(9000).sync();
            //todo 给cf注册监听器，监听我们关心的事件
            cf.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if (cf.isSuccess()) {
                        LOGGER.info("监听端口9000成功");
                    } else {
                        LOGGER.info("监听端口9000失败");
                    }
                }
            });
            //todo 对通道关闭进行监听，closeFuture是异步操作，监听通道关闭，sync方法是等待异步操作执行完毕
            cf.channel().closeFuture().sync();
        } catch (Exception e) {
            LOGGER.error("服务端异常,异常信息:{}",e.getMessage());
        }finally {
            //todo 优雅退出，释放线程池
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    private static final Logger LOGGER = LoggerFactory.getLogger(NettyServerHandler.class);

    /**
     * todo 读取客户端发送的数据
     * @param ctx 上下文对象, 含有通道channel，管道pipeline
     * @param msg 就是客户端发送的数据
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //todo 将msg转成一个ByteBuf，类似NIO的ByteBuffer
        ByteBuf buf = (ByteBuf) msg;
        LOGGER.info("客户端发送消息是:" + buf.toString(CharsetUtil.UTF_8));
    }

    /**
     * todo 数据读取完毕处理方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ByteBuf buf = Unpooled.copiedBuffer("HelloClient".getBytes(CharsetUtil.UTF_8));
        ctx.writeAndFlush(buf);
    }

    /**
     * todo 处理异常, 一般是需要关闭通道
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

2、客户端代码

public class NettyClient {

    public static final Logger LOGGER = LoggerFactory.getLogger(NettyClient.class);

    public static void main(String[] args) throws Exception {
        //todo 创建group线程组，负责处理事件循环，含有子线程NioEventLoop的个数默认为cpu核数的两倍
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //todo 创建客户端的启动对象
            Bootstrap bootstrap = new Bootstrap();
            //todo 设置线程组
            bootstrap.group(group)
                    //todo 使用NioSocketChannel作为服务器的通道实现
                    .channel(NioSocketChannel.class)
                    //todo 设置远程连接地址
                    .remoteAddress(new InetSocketAddress("127.0.0.1", 9000))
                    //todo 创建通道初始化对象，设置初始化参数
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //todo 添加处理器
                            ch.pipeline().addLast(new NettyClientHandler());
                        }
                    });
            LOGGER.info("netty client start ...");
            //todo 启动客户端去连接服务器端，connect是异步操作，sync方法是等待异步操作执行完毕
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 9000).sync();
            //todo 对通道关闭进行监听，closeFuture是异步操作，监听通道关闭，sync方法是等待异步操作执行完毕
            cf.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if (cf.isSuccess()) {
                        LOGGER.info("连接9000端口成功");
                    } else {
                        LOGGER.info("连接9000端口失败");
                    }
                }
            });
            cf.channel().closeFuture().sync();
        } catch (Exception e) {
            LOGGER.error("客户端异常,异常信息:{}",e.getMessage());
        }finally {
            //todo 优雅退出，释放线程池
            group.shutdownGracefully();
        }
    }
}

public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    private static final Logger LOGGER = LoggerFactory.getLogger(NettyClientHandler.class);

    /**
     * todo 当客户端连接服务器完成就会触发该方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf buf = Unpooled.copiedBuffer("HelloServer".getBytes(CharsetUtil.UTF_8));
        ctx.writeAndFlush(buf);
    }

    /**
     * todo 当通道有读取事件时会触发，即服务端发送数据给客户端
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        LOGGER.info("收到服务端的消息:" + buf.toString(CharsetUtil.UTF_8));
        LOGGER.info("服务端的地址： " + ctx.channel().remoteAddress());
    }

    /**
     * todo 处理异常,一般是需要关闭通道
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
avatar
文章
阅读
粉丝