Netty——Netty模型与Reactor模型原理与实战

原创

我是庄小焱 2023-03-21 10:41:05 博主文章分类：Netty ©著作权

文章标签 netty .net 客户端 System 文章分类 Html/CSS 前端开发

©著作权归作者所有：来自51CTO博客作者我是庄小焱的原创作品，请联系作者获取转载授权，否则将追究法律责任

摘要

根据Reactor的数量和处理资源池线程的数量不同，有3种典型的实现单Reactor单线程;单Reactor多线程;主从Reactor多线程。为了更好的理解有关以reactor模型的原理：

单Reactor单线程，前台接待员和服务员是同一个人，全程为顾客服
单Reactor多线程，1个前台接待员，多个服务员，接待员只负责接待
主从Reactor多线程，多个前台接待员，多个服务生

Netty模型

Netty——Netty模型与Reactor模型原理与实战_System

模型说明：

Netty抽象出两组线程池BossGroup专门负责接收客户端的连接，WorkerGroup专门负责网络的读写。

BossGroup和 WorkerGroup类型都是NioEventLoopGroup。

NioEventLoopGroup相当于一个事件循环组,这个组中含有多个事件循环，每一个事件循环是NioEventLoop。

NioEventLoop表示一个不断循环的执行处理任务的线程，每个NioEventLoop都有一个selector ,用于监听绑定在其上的socket的网络通讯。

NioEventLoopGroup可以有多个线程,即可以含有多个NioEventLoop6)每个Boss NioEventLoop。

循环执行的步骤有3步。

轮询accept事件
处理accept事件，与client建立连接,生成NioScocketChannel ,并将其注册到某个worker NlOEventLoop 上的selector
处理任务队列的任务，即runAllTasks

每个Worker NIOEventLoop循环执行的步骤。

轮询read, write事件
处理i/o事件，即read , write事件，在对应NioScocketChannel处理3.处理任务队列的任务，即runAllTasks

每个Worker NlOEventLoop处理业务时，会使用pipeline(管道)pipeline中包含了channel ,即通过pipeline可以获取到对应通道,管道中维护了很多的处理器。

netty模型总结：

Netty抽象出两组线程池，BossGroup专门负责接收客户端连接WorkerGroup专门负责网络读写操作。

NioEventLoop表示一个不断循环执行处理任务的线程，每个NioEventLoop都有一个selector，用于监听绑定在其上的socket网络通道。

NioEventLoop内部采用串行化设计，从消息的读取>解码-处理>编码->发送，始终由IO线程NioEventLoop负责

NioEventLoopGroup下包含多个NioEventLoop。
每个NioEventLoop中包含有一个Selector，一个taskQueue。
每个NioEventLoop的selector 上可以注册监听多个NioChannel。
每个NioChannel只会绑定在唯一的NioEventLoop 上。
每个NioChannel都绑定有一个自己的ChannelPipeline。

Netty代码实战

项目环境

JDK1.8（如果不是JDK1.8的话就可能需要更换NIO的架包）

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

NIOServer

package com.zhuangxiaoyan.netty.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * @Classname NettyServer
 * @Description TODO
 * @Date 2021/11/6 17:35
 * @Created by xjl
 */
public class NettyServer {

    public static void main(String[] args) throws InterruptedException {
        //创建BossGroup 和 WorkerGroup
        //1. 创建两个线程组 bossGroup 和 workerGroup
        //2. bossGroup 只是处理连接请求 , 真正的和客户端业务处理，会交给 workerGroup完成
        //3. 两个都是无限循环
        //4. bossGroup 和 workerGroup 含有的子线程(NioEventLoop)的个数
        //   默认实际 cpu核数 * 2
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            //创建服务器端的启动，配置启动参数
            ServerBootstrap bootstrap = new ServerBootstrap();

            //使用链式编程进行设置
            bootstrap.group(bossGroup, workGroup)//设置两个线程组
                    .channel(NioServerSocketChannel.class)//使用NioServerSocketChannel作为服务器的通道实现
                    .option(ChannelOption.SO_BACKLOG, 128)//设置线程队列 等待连接的个数
                    .childOption(ChannelOption.SO_KEEPALIVE, true)//设置保持互动的连接的状态
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        //创建一个通道测试对象（匿名通道） 给pipeline 设置处理器
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new NettyServerHandler());
                        }
                    });//给我们workerGroup的EventLoop 对应的管道设置处理器
            System.out.println("服务器准备就绪……");
            //保定一个端口并且同步 生成一个ChannelFuture 对象
            //启动服务器（绑定的端口）
            ChannelFuture cf = bootstrap.bind(9000).sync();

            //给cf 注册监听器，监控我们关心的事件
            cf.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if (cf.isSuccess()) {
                        System.out.println("监听端口 9000 成功");
                    } else {
                        System.out.println("监听端口 9000 失败");
                    }
                }
            });

            //对关闭的通道进行监听
            cf.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}

NioServerHandler

package com.zhuangxiaoyan.netty.server;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

import java.nio.ByteBuffer;

/**
 * @Classname NettyServerHandler
 * @Description 1我们自定义一个Handler需要继续netty规定好的某个HandlerAdapter(规范)
 * 2这时我们自定义一个Handler ,才能称为一个handLer
 * @Date 2021/11/6 17:52
 * @Created by xjl
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    //读取数据的实际 这里我们可以读取客户端的发送的消息

    /**
     * @description ChannelHandlercontext ctx:上下文对象，含有管道pipeline  地址
     * Object msg 就是客户端发送的数据默认object
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx=" + ctx);
        //将msg 转移到一个bytebuf 与NIO的buffer 是有区别的。
        ByteBuf buf = (ByteBuf) msg;

        System.out.println("客户端发送的消息是：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端的地址是：" + ctx.channel().remoteAddress());
    }

    //读取消息完毕数据
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //writeAndFlush 是write +flush
        //将数据写到缓冲中并刷新
        //一般的 我们将发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端 狗狗……", CharsetUtil.UTF_8));
    }

    //处理异常 医保是需要关闭管道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

NioClient

package com.zhuangxiaoyan.netty.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * @Classname NettyClinent
 * @Description TODO
 * @Date 2021/11/6 17:35
 * @Created by xjl
 */
public class NettyClinent {
    public static void main(String[] args) throws InterruptedException {
        //客户端只需要一个事件循环组
        EventLoopGroup eventExecutors = new NioEventLoopGroup();

        try {
            //创建客户端启动对象
            //注意从客户端使用不是ServerBootStrap而是 BootStrap
            Bootstrap bootstrap = new Bootstrap();
            //设置相关参数
            bootstrap.group(eventExecutors)//设置线程组
                    .channel(NioSocketChannel.class)//设置客户通道的实现类
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new NettyClientHandler());//加入自己的处理器
                        }
                    });
            System.out.println("客户端准备好了……");
            String host = "127.0.0.1";
            int PORT = 9000;
            //启动客户端去连接服务器端
            //关于的channelFuture 要分析 涉及到netty的异步模型
            ChannelFuture channelFuture = bootstrap.connect(host, PORT).sync();

            //给关系的通道进行监听
            channelFuture.channel().closeFuture().sync();
        } finally {
            eventExecutors.shutdownGracefully();
        }
    }
}

NioClientHandler

package com.zhuangxiaoyan.netty.client;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

import java.nio.ByteBuffer;

/**
 * @Classname NettyClientHandler
 * @Description TODO
 * @Date 2021/11/6 18:23
 * @Created by xjl
 */
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    //当通道就绪就会触发该方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端" + ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("hell, server :猪猪…… ", 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();
    }
}

Reactor模式模型

Netty——Netty模型与Reactor模型原理与实战_.net_02

模型说明：

Reactor模式，通过一个或多个输入同时传递给服务处理器的模式(基于事件驱动)

服务器端程序处理传入的多个请求,并将它们同步分派到相应的处理线程，因此Reactor模式也叫
Dispatcher模式

Reactor模式使用lo复用监听事件,收到事件后,分发给某个线程(进程),这点就是网络服务器高并发处理关键.

Reactor: Reactor在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序来对lO事件做出反应。它就像公司的电话接线员，它接听来自客户的电话并将线路转移到适当的联系人;

Handlers:处理程序执行I/0事件要完成的实际事件，类似于客户想要与之交谈的公司中的实际官员。Reactor通过调度适当的处理程序来响应\/O事件，处理程序执行非阻塞操作。

Reactor模式的优点：

基于I/o复用模型:多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象等待，无需阻塞等待所有连接。当某个连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。
基于线程池复用线程资源:不必再为每个连接创建线程，将连接完成后的业务处理任务分配给线程进行处理，一个线程可以处理多个连接的业务。
响应快，不必为单个同步时间所阻塞，虽然Reactor本身依然是同步的。
可以最大程度的避免复杂的多线程及同步问题，并且避免了多线程/进程的切换开销
扩展性好，可以方便的通过增加 Reactor实例个数来充分利用CPU资源。
复用性好，Reactor模型本身与具体事件处理逻辑无关，具有很高的复用性。

单Reactor单线程模型

Netty——Netty模型与Reactor模型原理与实战_客户端_03

模型说明：

Select是前面I/O复用模型介绍的标准网络编程API，可以实现应用程序通过一个阻基对象监听多路连接请求。
Reactor对象通过Select监控客户端请求事件，收到事件后通过Dispatch进行分发
如果是建立连接请求事件，则由Acceptor通过Accept处理连接请求，然后创建一个Handler对象处理连接完成后的后续业务处理
如果不是建立连接事件，则 Reactor会分发调用连接对应的 Handler来响应5) Handler会完成Read→业务处理→Send的完整业务流程

结合实例:服务器端用一个线程通过多路复用搞定所有的IO操作（包括连接，读、写等)，编码简单，清晰明了，但是如果客户端连接数量较多，将无法支撑，前面的NIO案例就属于这种模型。

单Reactor单线程优缺点分析:

优点:

模型简单，没有多线程、进程通信、竞争的问题，全部都在一个线程中完成

缺点:

性能问题，只有一个线程，无法完全发挥多核CPU的性能。Handler在处理某个连接上的业务时，整个进程无法处理其他连接事件，很容易导致性能瓶颈
缺点:可靠性问题，线程意外终止，或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部消息，造成节点故障
使用场景:客户端的数量有限，业务处理非常快速，比如 Redis在业务处理的时间复杂度O(1)的情况

单 Reactor多线程模型

Netty——Netty模型与Reactor模型原理与实战_.net_04

模型说明：

Reactor对象通过select监控客户端请求事件,收到事件后，通过dispatch进行分发
如果建立连接请求,则右Acceptor通过accept处理连接请求,然后创建一个Handler对象处理完成连接后的各种事件
如果不是连接请求，则由reactor分发调用连接对应的handler来处理
handler只负责响应事件，不做具体的业务处理,通过read读取数据后，会分发给后面的worker线程池的某个线程处理业务
worker线程池会分配独立线程完成真正的业务，并将结果返回给handler
handler收到响应后，通过send将结果返回给client

单Reactor多线程优缺点分析:

优点:

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

缺点:

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

主从Reactor多线程

Netty——Netty模型与Reactor模型原理与实战_.net_05

模型说明：

Reactor主线程MainReactor对象通过select监听连接事件,收到事件后，通过Acceptor处理连接事件。
当Acceptor处理连接事件后，MainReactor将连接分配给SubReactor。
subreactor将连接加入到连接队列进行监听,并创建handler进行各种事件处理。
当有新事件发生时，subreactor就会调用对应的handler处理handler 通过read读取数据，分发给后面的worker线程处理
worker线程池分配独立的worker线程进行业务处理，并返回结果
handler收到响应的结果后，再通过send将结果返回给client
Reactor主线程可以对应多个Reactor子线程,即MainRecator可以关联多个SubReactor

主从Reactor多线程优缺点:

优点:

父线程与子线程的数据交互简单职责明确，父线程只需要接收新连接，子线程完成后续的业务处理。

父线程与子线程的数据交互简单，Reactor主线程只需要把新连接传给子线程，子线程无需返回数据。

缺点:

编程复杂度较高

结合实例:这种模型在许多项目中广泛使用，包括Nginx主从Reactor多进程模型，Memcached主从多线程，Netty主从多线程模型的支持。

上一篇：Netty——异步(Future-Callback)模型的原理解析

下一篇：Netty——TaskQueue与ScheduleTaskQueue源码解析

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯