Netty网络框架学习笔记-3(Netty入门_2022-02-17)

1.0 使用Netty好处 (Netty官网、GitHub)

原生的NIO编写网络编程需要熟悉Selector、Channel 、Buffer, 并有很多异常情况需要自己考虑解决,

使用Netty 很好的帮我们解决了很多异常的业务场景, 封装了NIO底层API, 简化开发网络编程方式进行快速的开发, 例如: 客户端的断连重连, 网络闪断、半包、沾包读写、失败缓存, 网络拥堵等等异常情况。

官网推荐使用的是4.X版本, 最低JDK版本需要1.6

2.0 传统/Reactor模式

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

缺点:

采用阻塞 IO 模式获取输入的数据,

每个连接都需要独立的线程完成数据的输入，业务处理, 数据返回。

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

优点:

编程开发调试简单, 容易理解

2.2 Reactor 模式

针对传统阻塞 I/O 服务模型的 2 个缺点，Reactor 解决方案:

1- 基于 I/O 复用模型：多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象等待，无需阻塞等待所有连

接。当某个连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理

Reactor 对应的叫法: 1. 反应器模式 2. 分发者模式(Dispatcher) 3. 通知者模式(notifier)

2- 基于线程池复用线程资源：不必再为每个连接创建线程，将连接完成后的业务处理任务分配给线程进行处理

Reactor 模式中核心组成：

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

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

根据 Reactor 的数量和处理资源池线程的数量不同，有 3 种典型的实现

2.2.1 单 Reactor 单线程 (图片)

(服务器端用一个线程通过多路复用搞定所有的 IO 操作（包括连接，读、写等），但是如果客户端连接数量较多，将无法支撑，前面的 NIO 学习笔记就属于这种模型)

优点：编码简单，清晰明了，模型简单，没有多线程、进程通信、竞争的问题，全部都在一个线程中完成

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

使用场景在于: 客户端的连接数量有限，业务处理非常快速，比如 Redis 在业务处理的时间复杂度 O(1) 的情况

2.2.2 单 Reactor 多线程 (图片)

1- Reactor 对象通过 select 监控客户端请求事件, 收到事件后，通过 dispatch 进行分发

2- 如果建立连接请求, 则由 Acceptor 通过 accept 处理连接请求, 然后创建一个 Handler 对象处理完成连接后的各种事件

3- 如果不是连接请求，则由 reactor 分发调用连接对应的 handler 来处理

4- handler 只负责响应事件，不做具体的业务处理, 通过 read 读取数据后，会分发给后面的 worker 线程池的某个线程处理业务

5- worker 线程池会分配独立线程完成真正的业务，并将结果返回给 handler

6- handler 收到响应后，通过 send 将结果返回给 client

优点：可以充分的利用多核 cpu 的处理能力, reactor 处理建立连接与读取请求参数、响应、分发处理业务, 处理耗时业务是使用多个线程

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

2.2.3 主从 Reactor 多线程 (图片)

针对单 Reactor 多线程模型中，Reactor 在单线程中运行，高并发场景下容易成为性能瓶颈，可以让 Reactor 在多线程中运行

1- Reactor 主线程 MainReactor 对象通过 select 监听连接事件, 收到事件后，通过 Acceptor 处理连接事件

2- 当 Acceptor 处理连接事件后，MainReactor 将连接分配给 SubReactor

3- subreactor 将连接加入到连接队列进行监听,并创建 handler 进行各种事件处理

4- 当有新事件发生时， subreactor 就会调用对应的 handler 处理

5- handler 通过 read 读取数据，分发给后面的 worker 线程处理

6- worker 线程池分配独立的 worker 线程进行业务处理，并返回结果

7- handler 收到响应的结果后，再通过 send 将结果返回给 client

8- Reactor 主线程可以对应多个 Reactor 子线程, 即 MainRecator 可以关联多个 SubReactor

优点：父线程与子线程的数据交互简单职责明确，父线程只需要接收新连接，子线程完成后续的业务处理, 父线程与子线程的数据交互简单，Reactor 主线程只需要把新连接传给子线程，子线程无需返回数据。

Reactor 主线程只负责处理建立连接, 连接请求的读写交由子SubReactor , 子SubReactor耗时的业务处理交给工作线程池。

缺点：编程复杂度较高

2.2.4 Reactor 模式具有如下的优点

响应快，不必为单个同步时间所阻塞，虽然 Reactor 本身依然是同步的
可以最大程度的避免复杂的多线程及同步问题，并且避免了多线程/进程的切换开销
扩展性好，可以方便的通过增加 Reactor 实例个数来充分利用 CPU 资源
复用性好，Reactor 模型本身与具体事件处理逻辑无关，具有很高的复用性

3.0 Netty 模型

3.1 工作原理示意图-简单版

3.2 工作原理示意图-详细版

4.0 `Netty`入门案例 (官网文档、中文文档、《在线Netty 实战》

4.1 引入netty依赖

<dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId> <!-- Use 'netty-all' for 4.0 or above -->
            <version>4.1.74.Final</version>
</dependency>

4.2 netty服务端编写

/**
 * @Author: ZhiHao
 * @Date: 2022/2/16 15:25
 * @Description:
 * @Versions 1.0
 **/
@Slf4j
public class NettyService {

    public static void main(String[] args) {
        // 1-创建boss事件(线程)循环组, bossGroup 只是处理连接请求 , 真正的和客户端业务处理，会交给 workerGroup 完成
        // bossGroup 和 workerGroup 含有的子线程(NioEventLoop)的个数, 默认实际 cpu 核数 * 2
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        // 2-创建worker事件循环组, 两个事件循环组都是无限循环
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 3-创建服务器引导启动对象, 配置启动配置参数
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            // 绑定事件(线程)循环组
            serverBootstrap.group(bossGroup, workerGroup)
                    // 使用NIO非阻塞服务器通道, 用于实例化一个新的类Channel来接受传入的连接。
                    .channel(NioServerSocketChannel.class)
                    // 设置线程队列得到连接个数
                    .option(ChannelOption.SO_BACKLOG, 128)
                    // 设置保持活动连接状态
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    // 配置通道处理器 - ChannelInitializer
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            log.info("一个新的客户端连接成功:{}, hashcode:{}",ch,ch.hashCode())
                            // 获取对应通道的管道 (一个管道对应多个处理器)
                            ChannelPipeline pipeline = ch.pipeline();
                            // 添加框架提供的字符串编解码处理器
                            pipeline.addLast(new StringEncoder());
                            pipeline.addLast(new StringDecoder());
                            // 添加自定义读写数据处理器
                            pipeline.addLast(new NettyServerHandler());
                        }
                    });
            // 绑定端口并且同步生成一个ChannelFuture，开始接收进来的连接
            ChannelFuture future = serverBootstrap.bind(8888).sync();
            log.info("服务端启动成功, 等待客户端连接");
            // 对关闭通道进行监听
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            log.error("服务端发生异常", e);
        } finally {
            // 可以优雅地关闭你的服务器
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

4.2.1 编写服务端自定义处理器

/**
 * @Author: ZhiHao
 * @Date: 2022/2/16 16:28
 * @Description: ChannelInboundHandlerAdapter这个类实现了 ChannelInboundHandler接口，
 * ChannelInboundHandler 提供了许多事件处理的接口方法，然后你可以覆盖这些方法。
 * 现在仅仅只需要继承 ChannelInboundHandlerAdapter 类而不是你自己去实现接口方法。
 * @Versions 1.0
 **/
@Slf4j
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * 覆盖了 chanelRead() 事件处理方法。每当从客户端收到新的数据时，这个方法会在收到消息时被调用
     * ChannelHandlerContext ctx:上下文对象, 含有 管道 pipeline , 通道 channel, 地址
     * Object msg: 就是客户端发送的数据 默认 Object类型, 如果没有指定服务器编解码, 收到的消息的类型是 ByteBuf, 指定后是指定类型
     * ByteBuf 是 Netty 提供的，不是 NIO 的 ByteBuffer
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        log.info("服务器读取线程: {} ",Thread.currentThread().getName());
        log.info("server ctx:{}", ctx);
        Channel channel = ctx.channel();
        // //本质是一个双向链接, 出站入站
        ChannelPipeline pipeline = ctx.pipeline();
        log.info("看看 channel 和 pipeline 的关系");
        if (pipeline.channel() == channel){
            log.info("管道中的通道与处理器上下文通道是同一个对象");
        }
        String message = (String) msg;
        log.info("客户端发送消息是:{}", message);
        log.info("客户端地址:{}",channel.remoteAddress());
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //ctx.write(Object) 方法不会使消息写入到通道上，
        // 他被缓冲在了内部，你需要调用 ctx.flush() 方法来把缓冲区中数据强行输出。
        // 或者你可以用更简洁的 cxt.writeAndFlush(msg) 以达到同样的目的。
        ctx.writeAndFlush("帅哥客户端你好");
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 当发生异常时关闭通道
        ctx.close();
    }
}

4.3 netty客户端编写

@Slf4j
public class NettyClient {

    public static void main(String[] args) {
        // 1-创建workerGroup事件(线程)循环组
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 3-创建客户端引导对象,
            // BootStrap 和 ServerBootstrap 类似,不过他是对非服务端的 channel 而言，比如客户端或者无连接传输模式的 channel。
            Bootstrap bootstrap = new Bootstrap();
            // 绑定事件(线程)循环组
            bootstrap.group(workerGroup)
                    // 使用NIO非阻塞通道, 用于实例化一个新的类Channel来处理读取。
                    .channel(NioSocketChannel.class)
                    // 设置保持活动连接状态
                    .option(ChannelOption.SO_KEEPALIVE, true)
                    // 配置通道处理器 - ChannelInitializer
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 获取对应通道的管道 (一个管道对应多个处理器)
                            ChannelPipeline pipeline = ch.pipeline();
                            // 添加框架提供的字符串编解码处理器
                            pipeline.addLast(new StringEncoder());
                            pipeline.addLast(new StringDecoder());
                            // 添加自定义读写数据处理器
                            pipeline.addLast(new NettyClientHandler());
                        }
                    });

            // 启动客户端
            ChannelFuture future = bootstrap.connect("127.0.0.1", 8888).sync();
            log.info("客户端启动成功");
            // 对关闭通道进行监听
            future.channel().closeFuture().sync();
        } catch (Exception e) {

        } finally {
            // 可以优雅地关闭你的服务器
            workerGroup.shutdownGracefully();
        }
    }
}

4.3.1 编写客户端处理器

/**
 * @Author: ZhiHao
 * @Date: 2022/2/16 16:28
 * @Description: 基本与服务端一致
 * @Versions 1.0
 **/
@Slf4j
public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    /**
     * 当通道激活(就绪)就会触发该方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        log.info("客户端通道准备完成, 线程: {} ",Thread.currentThread().getName());
        ctx.writeAndFlush("帅哥服务端-1你好");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        log.info("客户端读取线程: {} ",Thread.currentThread().getName());
        log.info("server ctx =" + ctx);
        Channel channel = ctx.channel();
        // //本质是一个双向链接, 出站入站
        ChannelPipeline pipeline = ctx.pipeline();
        log.info("看看 channel 和 pipeline 的关系");
        if (pipeline.channel() == channel){
            log.info("管道中的通道与处理器上下文通道是同一个对象");
        }
        String message = (String) msg;
        log.info("服务端发送消息是:{}", message);
        log.info("服务端地址:{}",channel.remoteAddress());
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //ctx.write(Object) 方法不会使消息写入到通道上，
        // 他被缓冲在了内部，你需要调用 ctx.flush() 方法来把缓冲区中数据强行输出。
        // 或者你可以用更简洁的 cxt.writeAndFlush(msg) 以达到同样的目的。
        //ctx.writeAndFlush("帅哥服务端-2你好");
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 当发生异常时关闭通道
        ctx.close();
    }
}

测试结果:

17:54:10.338 [main] INFO com.zhihao.netty.rudiments.NettyService - 服务端启动成功, 等待客户端连接
17:54:15.456 [nioEventLoopGroup-3-1] INFO com.zhihao.netty.rudiments.NettyServerHandler - 服务器读取线程: nioEventLoopGroup-3-1 
17:54:15.467 [nioEventLoopGroup-3-1] INFO com.zhihao.netty.rudiments.NettyServerHandler - 看看 channel 和 pipeline 的关系
17:54:15.467 [nioEventLoopGroup-3-1] INFO com.zhihao.netty.rudiments.NettyServerHandler - 管道中的通道与处理器上下文通道是同一个对象
17:54:15.467 [nioEventLoopGroup-3-1] INFO com.zhihao.netty.rudiments.NettyServerHandler - 客户端发送消息是:帅哥服务端-1你好
17:54:15.467 [nioEventLoopGroup-3-1] INFO com.zhihao.netty.rudiments.NettyServerHandler - 客户端地址:/127.0.0.1:55597
-----------------------------------------------分割线----------------------------------------------------------------
17:54:15.396 [nioEventLoopGroup-2-1] INFO com.zhihao.netty.rudiments.NettyClientHandler - 客户端通道准备完成, 线程: nioEventLoopGroup-2-1 
17:54:15.414 [main] INFO com.zhihao.netty.rudiments.NettyClient - 客户端启动成功
17:54:15.480 [nioEventLoopGroup-2-1] INFO com.zhihao.netty.rudiments.NettyClientHandler - 看看 channel 和 pipeline 的关系
17:54:15.480 [nioEventLoopGroup-2-1] INFO com.zhihao.netty.rudiments.NettyClientHandler - 管道中的通道与处理器上下文通道是同一个对象
17:54:15.480 [nioEventLoopGroup-2-1] INFO com.zhihao.netty.rudiments.NettyClientHandler - 服务端发送消息是:帅哥客户端你好
17:54:15.480 [nioEventLoopGroup-2-1] INFO com.zhihao.netty.rudiments.NettyClientHandler - 服务端地址:/127.0.0.1:8888

4.4 EventLoop任务队列

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

用户自定义定时任务

@Slf4j
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        Channel channel = ctx.channel();
        ChannelPipeline pipeline = ctx.pipeline();
        String message = (String) msg;
        log.info("客户端发送消息是:{}", message);
        log.info("客户端地址:{}", channel.remoteAddress());
        // 假设这里我们有一个非常耗时长的业务可以异步执行的话, (PS: 注意这里使用的是EventLoop中的唯一线程=用于处理各种通道读写)
        // 提交该 channel 对应的 NIOEventLoop 的 taskQueue队列中 中延迟执行,
        EventLoop eventLoop = channel.eventLoop();
        eventLoop.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(8);
                log.info("服务器读取线程-eventLoop: {} ", Thread.currentThread().getName());
                log.info("eventLoop: {} ", channel.eventLoop());
                ctx.writeAndFlush("延迟8秒后发送帅哥客户端你好");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 定时执行的task, 该任务是提交到 scheduledTaskQueue队列中
        eventLoop.schedule(()->{
            try {
                ctx.writeAndFlush("5秒定时发送帅哥客户端你好");
            } catch (Exception e) {
                e.printStackTrace();
            }
        },5,TimeUnit.SECONDS);
    }
}

所以长时间耗时的业务任务, 建议不要直接读取方法内执行业务任务执行, 会阻塞worker工作线程长时间, 其他客户端无法读取,

而且一般线程组不会设置为一个, 让所有客户端都使用一个线程。
1

posted @ 2022-02-18 20:07 懵懵懂懂的猫阅读(133) 评论(0) 收藏举报

刷新页面返回顶部

Loading-正在加载, 请稍后

懵懵懂懂的猫

Netty网络框架学习笔记-3(Netty入门_2022-02-17)

1.0 使用Netty好处 (Netty官网、GitHub)

2.0 传统/Reactor模式

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

2.2 Reactor 模式

2.2.1 单 Reactor 单线程 (图片)

2.2.2 单 Reactor 多线程 (图片)

2.2.3 主从 Reactor 多线程 (图片)

2.2.4 Reactor 模式具有如下的优点

3.0 Netty 模型

3.1 工作原理示意图-简单版

3.2 工作原理示意图-详细版

4.0 `Netty`入门案例 (官网文档、中文文档、《在线Netty 实战》

4.1 引入netty依赖

4.2 netty服务端编写

4.2.1 编写服务端自定义处理器

4.3 netty客户端编写

4.3.1 编写客户端处理器

4.4 EventLoop任务队列

公告

Loading-正在加载, 请稍后

懵懵懂懂的猫

Netty网络框架学习笔记-3(Netty入门_2022-02-17)

1.0 使用Netty好处 (Netty官网 、GitHub)

2.0 传统/Reactor模式

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

2.2 Reactor 模式

2.2.1 单 Reactor 单线程 (图片)

2.2.2 单 Reactor 多线程 (图片)

2.2.3 主从 Reactor 多线程 (图片)

2.2.4 Reactor 模式具有如下的优点

3.0 Netty 模型

3.1 工作原理示意图-简单版

3.2 工作原理示意图-详细版

4.0 Netty入门案例 (官网文档 、中文文档 、《在线Netty 实战》

4.1 引入netty依赖

4.2 netty服务端编写

4.2.1 编写服务端自定义处理器

4.3 netty客户端编写

4.3.1 编写客户端处理器

4.4 EventLoop任务队列

公告

1.0 使用Netty好处 (Netty官网、GitHub)

4.0 `Netty`入门案例 (官网文档、中文文档、《在线Netty 实战》