抽丝剥茧Reactor模式

最新推荐文章于 2025-07-14 11:28:48 发布
原创 最新推荐文章于 2025-07-14 11:28:48 发布 · 置顶 · 4.3w 阅读 · 90 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#reactor #设计模式 #nio #多线程

      今天在看书的时候看到了一个新的设计模式——Reactor模式，这个模式是出现在NIO中，至于这到底是个什么模式，今天我们来细说一下。

一、是什么

1、概念

      reactor设计模式，是一种基于事件驱动的设计模式。Reactor框架是ACE各个框架中最基础的一个框架，其他框架都或多或少地用到了Reactor框架。
      在事件驱动的应用中，将一个或多个客户的服务请求分离（demultiplex）和调度（dispatch）给应用程序。在事件驱动的应用中，同步地、有序地处理同时接收的多个服务请求。
      reactor模式与外观模式有点像。不过，观察者模式与单个事件源关联，而反应器模式则与多个事件源关联 。当一个主体发生改变时，所有依属体都得到通知。

2、优点

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

3、缺点

      1）相比传统的简单模型，Reactor增加了一定的复杂性，因而有一定的门槛，并且不易于调试。
      2）Reactor模式需要底层的Synchronous Event Demultiplexer支持，比如Java中的Selector支持，操作系统的select系统调用支持，如果要自己实现Synchronous Event Demultiplexer可能不会有那么高效。
      3） Reactor模式在IO读写数据时还是在同一个线程中实现的，即使使用多个Reactor机制的情况下，那些共享一个Reactor的Channel如果出现一个长时间的数据读写，会影响这个Reactor中其他Channel的相应时间，比如在大文件传输时，IO操作就会影响其他Client的相应时间，因而对这种操作，使用传统的Thread-Per-Connection或许是一个更好的选择，或则此时使用Proactor模式。

二、架构模式

1、架构图

这里写图片描述

2、构成

Handles ：表示操作系统管理的资源，我们可以理解为fd。

Synchronous Event Demultiplexer ：同步事件分离器，阻塞等待Handles中的事件发生。

Initiation Dispatcher ：初始分派器，作用为添加Event handler（事件处理器）、删除Event handler以及分派事件给Event handler。也就是说，Synchronous Event Demultiplexer负责等待新事件发生，事件发生时通知Initiation Dispatcher，然后Initiation Dispatcher调用event handler处理事件。

Event Handler ：事件处理器的接口

Concrete Event Handler ：事件处理器的实际实现，而且绑定了一个Handle。因为在实际情况中，我们往往不止一种事件处理器，因此这里将事件处理器接口和实现分开，与C++、Java这些高级语言中的多态类似。

3、模块交互

      1）我们注册Concrete Event Handler到Initiation Dispatcher中。
      2）Initiation Dispatcher调用每个Event Handler的get_handle接口获取其绑定的Handle。
      3）Initiation Dispatcher调用handle_events开始事件处理循环。在这里，Initiation Dispatcher会将步骤2获取的所有Handle都收集起来，使用Synchronous Event Demultiplexer来等待这些Handle的事件发生。
     4）当某个（或某几个）Handle的事件发生时，Synchronous Event Demultiplexer通知Initiation Dispatcher。
       5）Initiation Dispatcher根据发生事件的Handle找出所对应的Handler。
       6）Initiation Dispatcher调用Handler的handle_event方法处理事件。

三、代码注释

package com.linxcool.reactor;  
  
import java.io.IOException;  
import java.net.InetAddress;  
import java.net.InetSocketAddress;  
import java.nio.channels.SelectionKey;  
import java.nio.channels.Selector;  
import java.nio.channels.ServerSocketChannel;  
import java.util.Iterator;  
import java.util.Set;  
  
/** 
 * 反应器模式 
 * 用于解决多用户访问并发问题 
 *  
 * 举个例子：餐厅服务问题 
 *  
 * 传统线程池做法：来一个客人(请求)去一个服务员(线程) 
 * 反应器模式做法：当客人点菜的时候，服务员就可以去招呼其他客人了，等客人点好了菜，直接招呼一声“服务员” 
 *  
 * @author linxcool 
 */  
public class Reactor implements Runnable{  
    public final Selector selector;  
    public final ServerSocketChannel serverSocketChannel;  
  
    public Reactor(int port) throws IOException{  
        selector=Selector.open();  
        serverSocketChannel=ServerSocketChannel.open();  
        InetSocketAddress inetSocketAddress=new InetSocketAddress(InetAddress.getLocalHost(),port);  
        serverSocketChannel.socket().bind(inetSocketAddress);  
        serverSocketChannel.configureBlocking(false);  
          
        //向selector注册该channel    
        SelectionKey selectionKey=serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);  
  
        //利用selectionKey的attache功能绑定Acceptor 如果有事情，触发Acceptor   
        selectionKey.attach(new Acceptor(this));  
    }  
  
    @Override  
    public void run() {  
        try {  
            while(!Thread.interrupted()){  
                selector.select();  
                Set<SelectionKey> selectionKeys= selector.selectedKeys();  
                Iterator<SelectionKey> it=selectionKeys.iterator();  
                //Selector如果发现channel有OP_ACCEPT或READ事件发生，下列遍历就会进行。  
                while(it.hasNext()){  
                    //来一个事件 第一次触发一个accepter线程    
                    //以后触发SocketReadHandler  
                    SelectionKey selectionKey=it.next();  
                    dispatch(selectionKey);  
                    selectionKeys.clear();  
                }  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
      
    /** 
     * 运行Acceptor或SocketReadHandler 
     * @param key 
     */  
    void dispatch(SelectionKey key) {  
        Runnable r = (Runnable)(key.attachment());    
        if (r != null){    
            r.run();  
        }    
    }    
  
}  

package com.linxcool.reactor;  
  
import java.io.IOException;  
import java.nio.channels.SocketChannel;  
  
public class Acceptor implements Runnable{  
    private Reactor reactor;  
    public Acceptor(Reactor reactor){  
        this.reactor=reactor;  
    }  
    @Override  
    public void run() {  
        try {  
            SocketChannel socketChannel=reactor.serverSocketChannel.accept();  
            if(socketChannel!=null)//调用Handler来处理channel  
                new SocketReadHandler(reactor.selector, socketChannel);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

package com.linxcool.reactor;  
  
import java.io.IOException;  
import java.nio.ByteBuffer;  
import java.nio.channels.SelectionKey;  
import java.nio.channels.Selector;  
import java.nio.channels.SocketChannel;  
  
public class SocketReadHandler implements Runnable{  
    private SocketChannel socketChannel;  
    public SocketReadHandler(Selector selector,SocketChannel socketChannel) throws IOException{  
        this.socketChannel=socketChannel;  
        socketChannel.configureBlocking(false);  
          
        SelectionKey selectionKey=socketChannel.register(selector, 0);  
          
        //将SelectionKey绑定为本Handler 下一步有事件触发时，将调用本类的run方法。    
        //参看dispatch(SelectionKey key)    
        selectionKey.attach(this);  
          
        //同时将SelectionKey标记为可读，以便读取。    
        selectionKey.interestOps(SelectionKey.OP_READ);    
        selector.wakeup();  
    }  
      
    /** 
     * 处理读取数据 
     */  
    @Override  
    public void run() {  
        ByteBuffer inputBuffer=ByteBuffer.allocate(1024);  
        inputBuffer.clear();  
        try {  
            socketChannel.read(inputBuffer);  
            //激活线程池 处理这些request  
            //requestHandle(new Request(socket,btt));   
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

总结：

      reactor模式是javaNIO非堵塞技术的实现原理，我们不仅要知道其原理流程，还要知道其代码实现，当然这个reactor模式不仅仅在NIO中实现，而且在redies等其他地方也出现过，说明这个模式还是比较实用的，尤其是在多线程高并发的情况下使用。

华为18级工程师耗时三年才总结出这份Java亿级高并发核心编程手册
mxy2404830的博客
12-16 2201
移动时代、5G时代、物联网时代的大幕已经开启，新时代提升了对Java应用的高性能、高并发的要求，也抬升了Java工程师的技术台阶和面试门槛。 很多公司的面试题从某个侧面反映了生产场景的技术要求。之前只有BAT等大公司才有高并发技术相关的面试题，现在与Java项目相关的整个行业基本都涉及此类面试题。Java NIO、Reactor模式、高性能通信框架Netty、分布式锁、分布式ID、分布式缓存、高并发架构、JUC、JMM、高并发设计模式、线程池、微服务框架（如Spring Cloud、Nginx反向代理）等
玩转高并发，17年开发经验架构师，历时三年编写Java高并发三部曲
Java_zhujia的博客
11-28 1435
5G，IO，多屏合一，方物互联时代来了！太分n式、高并发、微服务架构己经成为Java后端应用的主流架构。但是对Java高并发，springcloudRPC底层原理、Nginx底层原理等核心知识，广大的Java开发同学们相对欠缺，而市面上这方面的书也较少。40岁资深一线老架构师，中南大学硕士，资深系统架构师、IT领域资深作家、著名博主、从业十余年，先后在华为、神州数码等公司从事技术研发、架构工作。
Reactor模式
GUI1259802368的博客
07-20 1708
处理web请求，主要有两种体系结构：thread-based（基于线程）和event-driven（基于事件驱动） architectures. 基于线程 基于线程的体系结构通常会使用多线程来处理客户端的请求，每当接收到一个请求，便开启一个独立的线程来处理。这种方式虽然是直观的，但是仅适用于并发访问量不大的场景，因为线程需要占用一定的内存资源，且操作系统在线程之间的...
java io面试题_Java面试高级篇—Java NIO：浅析I/O模型面试题15期
weixin_34757654的博客
02-12 335
在进入Java NIO编程之前，我们今天先来讨论一些比较基础的知识：I/O模型。本文先从同步和异步的概念 说起，然后接着阐述了阻塞和非阻塞的区别，接着介绍了阻塞IO和非阻塞IO的区别，然后介绍了同步IO和异步IO的区别，接下来介绍了5种IO模型，最后介绍了两种和高性能IO设计相关的设计模式(Reactor和Proactor)。以下是本文的目录大纲：一.什么是同步？什么是异步？二.什么是阻塞？什么是...
Reactor 模式详解
最新发布
刘皇叔说Java的博客
07-14 1123
它是 Nginx、Redis、Netty 等高性能系统的底层基础。，用于处理高并发 I/O 请求，核心思想是。
libevent源码深度剖析二
热门推荐
sparkliang的专栏
12-07 9万+
libevent源码深度剖析二——Reactor模式张亮前面讲到，整个libevent本身就是一个Reactor，因此本节将专门对Reactor模式进行必要的介绍，并列出libevnet中的几个重要组件和Reactor的对应关系，在后面的章节中可能还会提到本节介绍的基本概念。1 Reactor的事件处理机制首先来回想一下普通函数调用的机制：程序调用某函数?函数执行，程序等待?函
涵盖15个技术点：这份Java高并发核心编程文档（卷一二都有）是Java卷王的都来学，涨薪10K+都是小问题~
Trouvailless的博客
08-10 622
然后结合SimpleMockLock独占锁的释放流程、ReentrantLock的抢锁流程，图文并茂地剖析释放、抢占AQS锁的源码和原理。、线程的基本操作、线程池的核心原理、JUC的线程池架构、4种快捷创建线程池的方法。首先介绍使用显式锁的正确方法、显式锁的分类，然后揭秘CAS可能导致的“总线风暴”和CLH自旋锁，最后从实例出发介绍JUC中的可中断锁和不可中断锁、共享锁与独占锁、读写锁。——原子性问题、可见性问题和有序性问题，阐述JMM的核心原理，揭秘Java内存可见性和volatile关键字的底层知识。.
阿里专家分享的SpringCloudNginx高并发核心文档
公众号：该用户快成仙了
07-18 266
Spring Cloud+Nginx系统架构毫无疑问是当今的主流技术之一。分布式Spring Cloud微服务框架和高性能的Nginx反向代理Web服务的优秀组合，满足了各大产品和项目的可扩展、高可用、高性能架构的需求。然而根据笔者摸查，很多Java开发人员对Spring Cloud微服务、反向代理Nginx核心知识的掌握不够，仅停留在SpringCloud+Nginx基础配置、API使用的初级使用阶段。本文从设计模式和基础知识入手，抽丝剥茧，将高深莫测的高并发核心知识讲解得浅显易懂！
Reactor模式及在DSS中的体现
weixin_33966095的博客
08-16 346
　　Reactor模式是处理并发I/O比较常见的一种模式，用于同步I/O，中心思想是将所有要处理的I/O事件注册到一个中心I/O多路复用器上，同时主线程阻塞在多路复用器上；一旦有I/O事件到来或是准备就绪(区别在于多路复用器是边沿触发还是水平触发)，多路复用器返回并将相应I/O事件分发到对应的处理器中。 　　Reactor是一种事件驱动机制，和普通函数调用的不同之处在于：应用程序不是主动的调用某...
reactor模式
05-28
### Reactor模式详解 Reactor模式是一种事件驱动的并发编程模型，广泛应用于高性能网络编程中，用于处理大量并发连接[^3]。它通过事件循环（Event Loop）机制高效地管理I/O操作，适用于服务器端开发[^1]。 #### 核心概念 Reactor模式的核心思想在于利用操作系统提供的I/O多路复用机制（如`select`、`poll`、`epoll`等），高效地监听和分发事件，使得程序能够以非阻塞方式处理多个I/O事件[^3]。在Reactor模式中，一个单独的线程运行Reactor，负责监听和分发事件，并将事件分发给适当的处理程序来对I/O事件做出反应[^4]。 #### 实现细节 Reactor模式的实现通常包括以下几个关键部分： 1. **事件注册**：服务端通过初始分配器注册实例化句柄处理某类事件[^5]。 2. **事件监听**：Reactor使用I/O多路复用机制监听多个文件描述符上的事件。 3. **事件分发**：当事件到达时，Reactor将事件分发给相应的事件处理程序[^4]。 4. **事件处理**：事件处理程序执行具体的业务逻辑，完成事件的处理。 以下是一个简单的Reactor模式实现示例，基于Python中的`selectors`模块： ```python import selectors import socket sel = selectors.DefaultSelector() def accept(sock, mask): conn, addr = sock.accept() # Should be ready print(f"Accepted connection from {addr}") conn.setblocking(False) sel.register(conn, selectors.EVENT_READ, read) def read(conn, mask): data = conn.recv(1024) # Should be ready if data: print(f"Echoing {data!r} back to client") conn.send(data) # Hope it won't block else: print("Closing", conn) sel.unregister(conn) conn.close() sock = socket.socket() sock.bind(('localhost', 12345)) sock.listen(100) sock.setblocking(False) sel.register(sock, selectors.EVENT_READ, accept) while True: events = sel.select() for key, mask in events: callback = key.data callback(key.fileobj, mask) ``` #### 应用场景 Reactor模式在实际应用中被广泛采用，特别是在需要处理大量并发连接的场景下。以下是两个典型的例子： 1. **Netty框架**：Netty是一个异步事件驱动的网络应用框架，其核心设计正是基于Reactor模式。通过Reactor模式，Netty实现了高效的I/O操作和事件处理[^2]。 2. **Redis数据库**：Redis作为一个高性能的内存数据库，也采用了Reactor模式来处理客户端请求。Redis使用单线程事件循环来处理所有I/O操作，确保了高并发下的稳定性和性能[^1]。 #### 总结 Reactor模式通过事件驱动的方式，结合I/O多路复用机制，实现了高效的并发处理。无论是单线程还是多线程版本，Reactor模式都能灵活应对不同的应用场景。在实际开发中，掌握Reactor模式对于理解和优化网络应用框架至关重要。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值