网络编程模型 / Reactor_什么是网络编程知乎-CSDN博客

之前一直不理解 Reactor 模型的含义，后来在知乎上看见了一个 demo，再结合文字终于理解什么是 Reactor 模型了，这里分享给大家。

一、介绍

网络编程模型通常有如下几种：Reactor，Proactor，Asynchronous Completion Token and Acceptor-Connector。本文主要对最主流的 Reactor模型进行介绍。

通常网络编程模型处理的主要流程如下

initiate => receive => demultiplex => dispatch => process events

I/O 多路复用可以用作并发事件驱动（event-driven）程序的基础，即整个事件驱动模型是一个状态机，包含了状态（state）, 输入事件（input-event）, 状态转移（transition）, 状态转移即状态到输入事件的一组映射。通过 I/O 多路复用的技术检测事件的发生，并根据具体的事件（通常为读写），进行不同的操作，即状态转移。

Reactor 模式是一种典型的事件驱动的编程模型，Reactor 逆置了程序处理的流程，其基本的思想即为 Hollywood Principle — 'Don't call us, we'll call you'。

普通的函数处理机制为：调用某函数 -> 函数执行，主程序等待阻塞 -> 函数将结果返回给主程序 -> 主程序继续执行。

Reactor 事件处理机制为：主程序将事件以及对应事件处理的方法在 Reactor 上进行注册，如果相应的事件发生，Reactor 将会主动调用事件注册的接口，即 回调函数。libevent 封装了 epoll 并注册相应的事件（I/O读写，时间事件，信号事件）以及回调函数，实现的事件驱动的框架。

二、架构

1、事件（事件源）

linux 上为文件描述符，handler 即为注册在特定事件上的程序，事件发生通常在 linux 下为 I/O 事件，由操作系统触发。

2、Reactor （反应器）

事件管理的接口，内部使用 event demultiplexer 注册、注销事件；并运行事件循环，当有事件进入"就绪"状态时，调用注册事件的回调函数处理事件。

class Reactor {
public:
    int register_handler(EventHandler *pHandler, int event);

    int remove_handler(EventHandler *pHandler, int event);

    void handle_events(timeval *ptv);
}

3、Event demultiplexer（事件多路分发机制）

通常是由操作系统提供的 I/O 多路复用的机制，例如 select，epoll。程序首先将 handler（事件源）以及对应的事件注册到 event demultiplexer 上；当有事件到达时，event demultiplexer 就会发出通知，通知 Reactor 调用事件处理程序进行处理。

4、Event Handler（事件处理程序）

事件处理程序提供了一组接口，在 Reactor 相应的事件发生时调用，执行相应的事件处理，通常会绑定一个有效的 handler 。

class Event_Handler {
public:
    // events maybe read/write/timeout/close .etc
    virtual void handle_events(int events) = 0;

    virtual HANDLE get_handle() = 0;
}

三、实现

#include <sys/epoll.h>
#include <unistd.h>
#include <iostream>
#include <array>
#include <unordered_map>

typedef std::string EventType;
class MyEventDemultiplexer
{
public:
  static const int NO_FLAGS = 0;
  static const int BLOCK_INDEFINITELY = -1;
  static const int MAX_EVENTS = 5;

  MyEventDemultiplexer()
  {
    fileDescriptor = epoll_create1(NO_FLAGS);
    event.data.fd = STDIN_FILENO;
    //设置epoll event 为 EPOLLIN （对应文件描述符可读）， EPOLLPRI （对应文件描述符有紧急事件可读）
    event.events = EPOLLIN | EPOLLPRI;
  }

  ~MyEventDemultiplexer()
  {
    close(fileDescriptor);
  }

  int wait()
  {
    return epoll_wait(fileDescriptor, events.data(), MAX_EVENTS, BLOCK_INDEFINITELY);
  }

  int control()
  {
    return epoll_ctl(fileDescriptor, EPOLL_CTL_ADD, STDIN_FILENO, &event);
  }

private:
  int fileDescriptor;
  struct epoll_event event;
  std::array<epoll_event, MAX_EVENTS> events{};
};

class MyEventHandler
{
public:
  int handle_event(EventType et)
  {
    std::cout << "Event Handler: " << et << std::endl;
    return 0;
  }
};

class Reactor
{
public:
  Reactor()
  {
    m_event_demultiplexer.control();
  }
  void addHandler(std::string event, MyEventHandler callback)
  {
    handlers.emplace(std::move(event), std::move(callback));
  }

  void run()
  {
    while (true)
    {
      int numberOfEvents = wait();
      for (int i = 0; i < numberOfEvents; ++i)
      {
        std::string input;
        std::getline(std::cin, input);
        try
        {
          // 根据的具体的事件去找对应的handler，并执行相应的操作
          handlers.at(input).handle_event(EventType(input));
        }
        catch (const std::out_of_range &e)
        {
          std::cout << "no  handler for " << input << std::endl;
        }
      }
    }
  }

private:
  std::unordered_map<std::string, MyEventHandler> handlers{};
  MyEventDemultiplexer m_event_demultiplexer;

  int wait()
  {
    int numberOfEvents = m_event_demultiplexer.wait();
    return numberOfEvents;
  }
};

int main()
{
  Reactor reactor;

  reactor.addHandler("a", MyEventHandler{});
  reactor.addHandler("b", MyEventHandler{});
  reactor.run();
}

结果：

a
Event Handler: a
b
Event Handler: b
c
no  handler for c

转载于：深入理解Reactor 网络编程模型 - 知乎

（SAW：Game Over！）