Netty与Reactor线程模型

最新推荐文章于 2023-03-23 15:00:11 发布
最新推荐文章于 2023-03-23 15:00:11 发布
阅读量154 收藏
点赞数 1
分类专栏： Netty源码 文章标签： Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ws92dj/article/details/89787230
版权

Netty是一个高性能，异步的事件驱动的Java NIO框架，它的所有I/O操作都是异步非阻塞的，其使用了一种重要的设计模式，称为Reactor模式。

Reactor模式组件

在这里插入图片描述

1.Handle

  • 它识别由操作系统管理的资源。这些资源通常包括网络连接，打开文件，定时器，同步对象等。

2.Synchronous Event Demultiplexer（同步事件分离器）

  • 本质上是一个系统调用，用于等待事件的发生。调用它时会发生阻塞，直到同步事件分离器上有事件发生为止。对于linux操作系统来说，同步事件分离器就是i/o多路复用，如：select,poll,epoll。Java Nio中，同步事件分离器是selector，对应的方法是select()。

3.Event Handler（事件处理器）

  • 由多个回调方法构成，这些回调方法构成了与应用相关的对于某个事件的反馈机制。Netty相比于Java Nio来说，在事件处理器角色上进行了升级，为开发者提供了大量的回调方法，供我们在特定事件产生时来进行特定业务逻辑处理。

4.Concrete Event Handler（具体事件处理器）

  • 它是事件处理器的具体实现，它实现了事件处理器所提供的各个回调方法。从而实现了特定于业务的逻辑。

5.Initiation Dispatcher(初始分发器)

  • 实际上是Reactor角色，它本身定义了一些规范，这些规范用于控制事件的调度方式，同时又提供了应用进行事件处理器的注册，删除等方法。它本身是事件处理器的核心所在，会通过同步事件分离器等待事件的发生。一旦事件发生，它首先会分离出每一个事件，然后调用事件处理器，最后调用相关的回调方法来处理这些事件。

Reactor模式的流程

  1. 当应用向Initiation Dispatcher注册具体的事件处理器时，应用会标识出该事件处理器希望Initiation Dispatcher在某个事件发生时向其通知的该事件，该事件与Handle相关联。
  2. Initiation Dispatcher会要求每个事件处理器向其传递内部Handle，该Handle向操作系统标识了事件处理器。
  3. 当所有的事件处理器注册完毕后，应用会调用handle_events()方法来启动Initiation Dispatcher的事件循环。这时，Initiation Dispatcher会将每个注册的事件处理器的Handle合并起来，并使用同步事件分离器来等待这些事件的发生。比如说，tcp协议层会使用select同步事件分离器操作来等待客户端的数据到达连接的socket handle上。
  4. 当与某个事件源对应的Handle变为Ready状态时，同步事件分离器就会通知Initiation Dispatcher。
  5. Initiation Dispatcher会触发事件处理器的回调方法。从而响应这个处于Ready状态的handle。当事件发生时，Initiation Dispatcher会将被激活的Handler作为key来寻找并分发恰当的事件处理器回调方法。
  6. Initiation Dispatcher会回调事件处理器的handle_event方法来执行特定于应用的功能。从而响应这个事件，所发生的事件类型可以作为该方法参数并被该方法内部使用来执行额外的特定于服务的分离与分发。

代码示例

Reactor实现

/**
Java Nio实现Reactor模式
**/
public class Reactor {
    private static final Logger LOGGER = LoggerFactory.getLogger(Reactor.class);

    public static void main(String[] args)throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(8899));

        //selector对应同步事件分离器
        Selector selector = Selector.open();
        //同步事件分离器
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        //阻塞等待事件的发生
        while (selector.select() > 0){
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            while (iterator.hasNext()){
                SelectionKey selectionKey = iterator.next();
                iterator.remove();
                //对应的事件发生，进行相关逻辑处理
                if (selectionKey.isAcceptable()){
                    ServerSocketChannel accept = (ServerSocketChannel) selectionKey.channel();
                    SocketChannel socketChannel = accept.accept();
                    socketChannel.configureBlocking(false);
                    LOGGER.info("Accept request from {}",socketChannel.getLocalAddress());
                    //同步事件分离器会等待socket变为可读状态
                    socketChannel.register(selector,SelectionKey.OP_READ);
                }else if (selectionKey.isReadable()){
                    
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int count = socketChannel.read(byteBuffer);

                    if (count <= 0){
                        socketChannel.close();
                        selectionKey.cancel();
                        LOGGER.info("Received invalid data,close the connection");
                        continue;
                    }
                    LOGGER.info("Received message {}",new String(byteBuffer.array()));
                }
                selectionKeys.remove(selectionKey);

            }
        }


    }
}

上述代码中看出，多个channel可以注册到一个Selector上，实现了一个线程同时监控多个请求状态，注册时需要指定所关注的事件。

多Reactor实现

在这里插入图片描述

/**
*多Reactor模式
**/
public class MultiReactor {
    private static final Logger LOGGER = LoggerFactory.getLogger(MultiReactor.class);

    public static void main(String[] args)throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(8899));

        Selector selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        int coreNum = Runtime.getRuntime().availableProcessors();
        //subReactor的个数是当前核数的2倍，也是Netty的默认个数。
        Processor[] processors = new Processor[coreNum];
        for(int i = 0; i < processors.length;i++){
            processors[i] = new Processor();
        }

        int index = 0;
        while (selector.select() > 0){
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            for (SelectionKey selectionKey:selectionKeys){
                if (selectionKey.isAcceptable()){
                  ServerSocketChannel acceptServerSocketChannel   = (ServerSocketChannel)selectionKey.channel();
                    SocketChannel socketChannel = acceptServerSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    LOGGER.info("Accept request from {}",socketChannel.getRemoteAddress());
                    //轮询的方式
                    Processor processor = processors[(index++)%coreNum];
                    processor.addChannel(socketChannel);
                    processor.wakeup();
                }
            }

        }

    }
}

/**
*Processor.java
**/
public class Processor {
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class);
    private static final ExecutorService EXECUTOR_SERVICE = Executors.newFixedThreadPool(2*Runtime.getRuntime().availableProcessors());

    private Selector selector;

    public Processor()throws IOException {
    //每个Processor包含一个selector
        this.selector = SelectorProvider.provider().openSelector();
        start();
    }
    public void addChannel(SocketChannel socketChannel)throws IOException{
        socketChannel.register(selector, SelectionKey.OP_READ);
    }

    public void wakeup(){
        this.selector.wakeup();
    }
    public void start(){
        EXECUTOR_SERVICE.submit(()->{
                while (true){
                    if (selector.select(500) <= 0){
                        continue;
                    }
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iterator = selectionKeys.iterator();
                    while (iterator.hasNext()){
                        SelectionKey selectionKey = iterator.next();
                        iterator.remove();
                        if (selectionKey.isReadable()){
                            ByteBuffer buffer = ByteBuffer.allocate(1024);
                            SocketChannel socketChannel = (SocketChannel)selectionKey.channel();
                            int count = socketChannel.read(buffer);
                            if (count < 0){
                                socketChannel.close();
                                selectionKey.cancel();
                                LOGGER.info("{}\t Read ended",socketChannel);
                                continue;

                            }else if (count == 0){
                                LOGGER.info("{}\t Message size is 0",socketChannel);
                                continue;
                            }else {
                                LOGGER.info("{}\t Read message {}",socketChannel,new String(buffer.array()));
                            }
                        }
                    }
                }
        });
    }
}

Netty的注册流程可以看另外一篇文章https://blog.csdn.net/ws92dj/article/details/88783631。

Netty Reactor 线程模型
悟已往之不谏，知来者之可追
12-22 309
Reactor 线程模型是 Netty 实现高性能的核心所在，在 Netty 中 EventLoop 是 Reactor 线程模型的核心处理引擎，那么 EventLoop 到底是如何实现的呢？又是如何保证高性能和线程安全性的呢？ 说明：本文参考的 Netty 源码版本为 4.1.42.Final。 Reactor 线程执行的主流程 因为 Netty 是基于 NIO 实现的，所以推荐使用 NioEventLoop 实现，我们再次通过 NioEventLoop 的核心入口 run() 方法回顾 Netty
Netty Reactor面试连环问
最新发布
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
08-27 870
笔者分别带入索引0、5、8，进行与运算时，真正参与的二进制永远是和永远是7以内的进制，得出的结果分别是0、5、0，永远不会越界，并且运算性能还能得到保证。中查看是否有继续的任务，如果有则查看它的到期时间，并基于这个时长查询是否存在就绪的任务。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。
Netty的Reactor线程模型
xiaomin1991222的专栏
09-17 205
  上图是一个Reactor线程模型，基于select(),epoll()，Reactor线程将I/O调用请求和I/O操作分离开，理论上一个Reactor线程能处理N个网络I/O操作，但是当并发量很大的时候，一个Reactor线程就会出现响应缓慢，连接超时等问题。==========================================================...
Netty线程模型 - Reactor 模式
zhj52666的博客
11-09 383
我相信有很多人会对这个Reactor模式比较陌生，但是Netty这个名字大家都会比较熟悉，即使没有学习使用过，也会对它有所耳闻，它可以说是Java高性能网络编程的代名词。Reactor模式就是Netty线程模型设计的核心，本文我们就以Reactor模式入手，探究一下经典的设计。
Netty线程模型 Reactor模型
清风
11-07 487
线程模型 线程模型有传统阻塞I/O服务器模型和Reactor模型(网络主流模型) 根据Reactor的数量和处理资源池线程的数量不同，有3种典型的实现： 单Reactor单线程 单Reactor多线程 主从Reactor多线程 Netty基于主从Reactor多线程模型，并做了一些改进，其中主从Reactor多线程有多个Reactor 单线程Reactor模型 Java的NIO模式的Selector网络通讯，其实就是一个简单的Reactor模型。可以说是Reactor模型的朴素原型。 .
Netty之Reactor线程模型
c_c_y_CC的博客
03-19 181
Reactor 线程模型 一、传统线程模型与NIO模型 1. BIO 模型 传统 I/O 模型为同步阻塞式 I/O 模型，对于网络I/O而言，需要赋予每个连接一个线程，同时该线程会阻塞于I/O事件，无法操作执行其他任务 1.1 处理模型 每当有新连接到来时，创建一个新的线程以对新连接进行处理，可用***线程池***进行优化，但仍然无法应对高并发服务 1.2 服务端代码 public cl...
简单了解Java Netty Reactor三种线程模型
12-20
在Netty中，Reactor线程模型是其核心设计之一，用于处理并发连接和网络I/O操作。本文将详细介绍Reactor的三种线程模型，并结合Netty的线程模型进行解析。 ### 1. Reactor 单线程模型 Reactor单线程模型是指所有的I...
（java）netty框架—reactor线程模型详解
sylnb的博客
03-23 692
负责，线程池可以采用标准的JDK线程池实现，它包含一个任务队列和N个可用的线程，由这些NIO线程负责消息的读取、解码、编码和发送。缺点：多线程数据共享和访问比较复杂， reactor 处理所有的事件的监听和响应，在单线程运行， 在高并发场景容易出现性能瓶颈.使用场景：客户端的数量有限，业务处理非常快速，比如 Redis 在业务处理的时间复杂度 O(1) 的情况。​ 一个NIO线程可以同时处理N条链路，但是一个链路只对应一个NIO线程，防止发生并发操作问题。优点：可以充分的利用多核 cpu 的处理能力。
Netty核心精讲之Reactor线程模型源码分析.mp4
06-21
在深入探讨Netty的Reactor线程模型源码之前，我们需要先理解Reactor模式的基本概念。 Reactor模式是一种设计模式，常用于处理并发I/O事件。在多路复用I/O（如epoll、kqueue）中，Reactor模式是关键组成部分，它负责...
Netty入门（一） --- Reactor线程模型，Netty的线程模型，快速入门Demo
化身强盗的博客
01-21 1336
文章目录一、Netty概述1.1 简介1.2 原生NIO的问题1.3 Netty的优点二、线程模型2.1 传统阻塞IO服务模型特点：问题：2.2 Reactor模式2.2.1 单Reactor单线程流程说明：优缺点分析：2.2.2 单Reactor多线程流程说明：优缺点：2.2.3 主从Reactor多线程流程说明：优缺点：总结三、Netty模型原理描述：快速入门demo 一、Netty概述 1.1 简介 官网：https://netty.io/ Netty是一个NIO客户端服务器框架，它可以快速简单地开发
Netty Reactor线程模型
NullPointerException的博客
06-28 349
前两篇博文分别介绍了Java 线程模型：BIO NIO和Reactor线程模型，本篇博文将介绍Reactor线程模型在Netty中的实际应用。 Netty模型 Netty模型的简单介绍 Netty 主要基于主从 Reactors 多线程模型做了一定的改进，其中主从 Reactor 多线程模型有多个 Reactor。 BossGroup 线程维护 Selector , 只关注 Accecpt； 当接收到Accept事件，获取到对应的SocketChannel,封装成NIOScoketChannel并注.
Netty 线程模型（Reactor 线程模型）
程序猿进阶
12-14 4186
[Netty 线程模型（Reactor 线程模型） 当说到 Netty 线程模型的时候，一般首先会想到经典的 Reactor 线程模型，尽管不同的 NIO 框架对于 Reactor 模式的实现存在差异，但本质上还是遵循了 Reactor 的基础线程模式。 一、Reactor 单线程模型 无论是C++ 还是 Java 编写的网络框架，大多数都是基于 Reactor 模型进行设计和开发，Reactor 模型基于事件驱动，特别适合海量的 I/O 事件。 【1】Reactor 单线程模型，是指所有的 I/
Netty(一) Reactor 线程模型
qq_32092237的博客
09-20 159
什么是Reactor模型 Reactor模式含义为反应堆模式，专门用于处理请求的模式，它基于IO多路复用和事件驱动。 通过1个或多个线程接收请求，然后将请求转发至其他工作线程进行业务处理。Reactor模式适用于高并发场景，替代传统的多线程模式，提升系统的资源，提升吞吐量； 处理并发请求的技术历史 单线程处理 一个线程处理请求，后续请求排队阻塞，等前一个请求处理完才能处理后续请求连接 1个连接，1个线程 每来一个连接，就分配一个线程用于处理这个连接。由于资源限制，且频繁创建线程的消耗，引入了线程池对线程资源
netty - 线程模型 reactor
u012391423的博客
07-19 1258
目录 线程模型 1、传统IO服务模型 2、Reactor模式 reactor 三种模式： 总结 netty模型 执行流程简述 线程模型 1、传统IO服务模型 阻塞的IO模式获取输入数据，每个链接需要独立的线程完成数据传输及处理 当并发数较大时，创建大量线程，占用系统资源；线程创建后如无数据读写，将被阻塞 2、Reactor模式 reactor 针对传统的IO模型的两个缺点，解决方案： a、基于IO多路复用模型：多个连接共用一个阻塞对象。应用程序只需要在一.
Netty Reactor 线程模型（随记）
无怨无悔专栏
02-21 228
Netty被称为一个高性能、高可扩展性能的异步事件驱动的网络应用程序框架，它极大地简化了TCP和UDP客户端和服务器开发等网络编程。 Netty的Reactor模型中有四个核心概念： Resources资源（请求和任务） Synchronous Event Demultiplexer同步事件复用器 Dispatcher 分配器 Request Hand...
Netty框架之Reactor线程模型
wzs535131的博客
07-19 350
作为一个程序员，平时少不了要学习新的东西，最近学习Netty框架，Netty是由JBOSS提供的一个java开源框架，Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，Netty简化和流线化了网络应用的编程开发过程。 Netty就是基于Reactor线程模型开发的，我们今天来简单分析下： Reactor模型...
Netty源码分析系列之Reactor线程模型
天堂的博客
12-02 416
什么是Reactor线程模型？Netty作为一款高性能的网络框架，其底层使用的网络IO模型是什么呢？
Netty源码解析之Reactor线程模型
|-| [- |_ |_ ()
07-04 482
文章目录前言线程组的初始化发动机线程的初始化发动机启动select流程：轮询Channel上的事件selector空轮询BUGprocessSelectedKeys：处理事件服务端Channel处理事件一个新连接到服务端之后会发生什么事？客户端Channel处理事件runAllTasks：运行所有任务拿到定时任务执行任务Reactor线程模型 前言 个人认为，Netty中最核心的就是它的线程模型了...
Netty线程模型深度解析：从Reactor到NioEventLoop
Netty采用了主从多线程模型的变种，其核心组件是NioEventLoop。Netty中的NioEventLoop组成了一个线程组，每个NioEventLoop负责处理一部分连接。新连接进来后，会被分配给不同的NioEventLoop进行处理，这样可以确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值