Netty08——Netty模型

阿弥陀佛僧

已于 2022-03-10 20:39:11 修改

阅读量162

点赞数

分类专栏： Netty 文章标签： java 网络开发语言

于 2021-07-29 01:00:33 首次发布

本文链接：https://blog.csdn.net/rubulai/article/details/119191531

版权

Netty 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

一、工作原理

Netty 主要基于主从 Reactors 多线程模型做了一定的改进，其中主从 Reactor 多线程模型有多个 Reactor。
在这里插入图片描述
说明：
①BossGroup 线程维护其中一个Selector，它只关注Accept事件
②当接收到Accept事件，为其分配一个对应的SocketChannel，并将其封装成 NIOScoketChannel 并注册到 Worker 线程(事件循环)中的Selector，并进行维护
③当 Worker 线程监听到 Selector 中的通道发生自己感兴趣的事件后，就交由对应的Handler进行处理(注意 Handler 已经加入到通道)
在这里插入图片描述
说明：
①Netty 抽象出两组线程池：BossGroup 专门负责接收客户端的连接，WorkerGroup 专门负责网络的读写
②BossGroup 和 WorkerGroup 类型都是 NioEventLoopGroup，NioEventLoopGroup 相当于一个事件循环组，这个组中含有多个事件循环，每一个事件循环是 NioEventLoop，NioEventLoop 表示一个不断循环的执行处理任务的线程，每个 NioEventLoop 都有一个 Selector，用于监听绑定在其上的 Socket 的网络通讯
③NioEventLoopGroup 可以有多个线程，即可以含有多个 NioEventLoop
④每个 Boss NioEventLoop 循环执行的步骤有3步：
a、轮询 accept 事件
b、处理 accept 事件，与 client 建立连接，生成 NioScocketChannel，并将其注册到某个 worker NIOEventLoop 上的 selector
c、处理任务队列的任务，即 runAllTasks
⑤每个 Worker NIOEventLoop 循环执行的步骤也是3步：
a、轮询 read/write 事件
b、处理 I/O 事件，即 read/write 事件，在对应 NioScocketChannel 处理
c、处理任务队列的任务，即 runAllTasks
⑥每个Worker NIOEventLoop 处理业务时，会使用 pipeline(管道)，pipeline中包含了channel，即通过 pipeline 可以获取到对应通道，通道中维护了很多处理器，用于实际的业务处理

二、案例

1、客户端和服务端简单通信

服务端：

public class NettyServer {

    public static void main(String[] args) throws Exception {
        // 创建两个线程组：BossGroup和WorkerGroup
        // 两个线程组都是无限循环：BossGroup只处理连接请求，真正的业务处理交给WorkerGroup完成
        // BossGroup和WorkerGroup含有的子线程(NioEventLoop)的个数默认：cpu核心数 * 2
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 创建服务器端的启动对象，配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup) // 设置两个线程组
                    .channel(NioServerSocketChannel.class) // 使用NioSocketChannel作为服务器的通道实现
                    .option(ChannelOption.SO_BACKLOG, 128) // 设置线程队列得到连接个数
                    .childOption(ChannelOption.SO_KEEPALIVE, true) // 保持活动连接状态
                    .childHandler(new ChannelInitializer<SocketChannel>() {// 创建一个匿名通道测试对象
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 给pipeline设置处理器，给WorkerGroup的EventLoop对应的管道设置处理器，该处理器可以自定义，此处就是自定义的
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    });
            System.out.println("server is ready...");
            // 绑定端口并启动服务器
            ChannelFuture channelFuture = bootstrap.bind(6666).sync();
            // 对关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

自定义服务端处理器：

public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * 重写channelRead方法来读取实际数据
     *
     * @param ctx 上下文对象，含有管道 pipeline，通道 channel，地址等
     * @param msg 客户端发送的数据
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("服务器读取线程：" + Thread.currentThread().getName());
        System.out.println("server ctx = " + ctx);
        Channel channel = ctx.channel();
        ChannelPipeline pipeline = ctx.pipeline(); // 本质是一个双向链表，出站入站
        ByteBuf buf = (ByteBuf) msg;// ByteBuf是netty提供的，不是NIO的ByteBuffer
        System.out.println("客户端发送的消息是：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址：" + channel.remoteAddress());
    }

    /**
     * 数据读取完毕
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // 将数据写入到缓存并刷新，一般我们会对发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,客户端...", CharsetUtil.UTF_8));
    }

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

注：我们自定义的Handler必须实现netty的ChannelHandler接口或者继承netty提供的ChannelHandler接口的实现类，一般会选择继承 netty 提供的 HandlerAdapter
客户端：

public class NettyClient {

    public static void main(String[] args) throws Exception {
        // 客户端需要一个事件循环组
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            // 创建客户端启动对象，注意客户端使用的不是ServerBootstrap，而是Bootstrap
            Bootstrap bootstrap = new Bootstrap();
            // 设置参数
            bootstrap.group(group)// 设置线程组
                    .channel(NioSocketChannel.class)// 设置客户端通道的实现(反射)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyClientHandler());// 加入自己的处理器
                        }
                    });
            System.out.println("client ok...");
            // 启动客户端连接服务端
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6666).sync();
            // 对关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }

    }
}

自定义客户端处理器：

public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    /**
     * 通道就绪就会触发该方法
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client" + ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,服务端...", CharsetUtil.UTF_8));
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("服务端回复：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务器地址：" + ctx.channel().remoteAddress());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

2、任务队列中的 Task 有 3 种典型使用场景

①用户程序自定义的普通任务
②用户自定义的定时任务

public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 比如这里我们有一个非常耗时的业务，我们可以异步执行，将该任务提交到channel对应的NioEventLoop的taskQueue中
        ctx.channel().eventLoop().execute(new Runnable() {// 用户自定义的普通任务
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,客户端...", CharsetUtil.UTF_8));
                    System.out.println("channel code:" + ctx.channel().hashCode());
                } catch (Exception e) {
                    System.out.println("发生异常:" + e.getMessage());
                }
            }
        });

        ctx.channel().eventLoop().execute(new Runnable() {// 用户自定义的普通任务
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,客户端...", CharsetUtil.UTF_8));
                    System.out.println("channel code:" + ctx.channel().hashCode());
                } catch (Exception e) {
                    System.out.println("发生异常:" + e.getMessage());
                }
            }
        });

        // 用户自定义的定时任务，提交到scheduledTaskQueue中
        ctx.channel().eventLoop().schedule(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,客户端...", CharsetUtil.UTF_8));
                    System.out.println("channel code:" + ctx.channel().hashCode());
                } catch (Exception e) {
                    System.out.println("发生异常:" + e.getMessage());
                }
            }
        }, 5, TimeUnit.SECONDS);
    }
}

③非当前 Reactor 线程调用 Channel 的各种方法
例如在推送系统的业务线程里面，根据用户的标识，找到对应的 Channel 引用，然后调用 Write 类方法向该用户推送消息，就会进入到这种场景。最终的 Write 会提交到任务队列中后被异步消费

三、Netty模型总结

Netty 抽象出两组线程池：BossGroup 专门负责接收客户端连接，WorkerGroup 专门负责网络读写操作。
NioEventLoop 表示一个不断循环执行处理任务的线程，每个 NioEventLoop 都有一个 selector，用于监听绑定在其上的 socket 网络通道。NioEventLoop 内部采用串行化设计，消息的读取->解码->处理->编码->发送，始终由 IO 线程 NioEventLoop 负责。
NioEventLoopGroup 下包含多个 NioEventLoop，每个 NioEventLoop 中包含有一个 Selector，一个 taskQueue，每个 NioEventLoop 的 Selector 上可以注册监听多个 NioChannel，每个 NioChannel 只会绑定在唯一的 NioEventLoop 上，每个 NioChannel 都绑定有一个自己的 ChannelPipeline。