Reactor 模型与 Proactor 模型：深入解析与源码对比

本文链接：https://blog.csdn.net/qq_37037348/article/details/141036000

Reactor 模型与 Proactor 模型：深入解析与源码对比

在网络编程中，高性能的服务器设计是至关重要的。Reactor 模型和 Proactor 模型是两种常见的事件驱动架构，它们在处理并发请求时表现出色。本文将详细介绍这两种模型的原理、应用场景，并通过源码分析揭示它们的根本区别。

Reactor 模型

原理

Reactor 模型是一种事件驱动的设计模式，主要用于处理多个并发输入源。它的核心思想是将事件检测和事件处理分离，通过一个或多个事件处理器来处理不同的事件。Reactor 模型的主要组件包括：

Reactor：负责事件的检测和分发。
Handlers：负责处理具体的事件。
Demultiplexer：事件多路分离器，用于等待事件的发生。

工作流程

初始化：创建 Reactor 实例，注册事件处理器。
事件检测：Reactor 通过 Demultiplexer 等待事件的发生。
事件分发：当事件发生时，Reactor 将事件分发给相应的事件处理器。
事件处理：事件处理器处理具体的事件。

源码分析

以下是一个简单的 Reactor 模型实现示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>

#define MAX_EVENTS 10

typedef struct {
    int fd;
    void (*handler)(int);
} EventHandler;

typedef struct {
    int epoll_fd;
    struct epoll_event events[MAX_EVENTS];
    EventHandler handlers[MAX_EVENTS];
} Reactor;

void init_reactor(Reactor *reactor) {
    reactor->epoll_fd = epoll_create1(0);
    if (reactor->epoll_fd == -1) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }
}

void register_handler(Reactor *reactor, int fd, void (*handler)(int)) {
    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = fd;
    if (epoll_ctl(reactor->epoll_fd, EPOLL_CTL_ADD, fd, &event) == -1) {
        perror("epoll_ctl: add");
        exit(EXIT_FAILURE);
    }
    reactor->handlers[fd].fd = fd;
    reactor->handlers[fd].handler = handler;
}

void run_reactor(Reactor *reactor) {
    while (1) {
        int nfds = epoll_wait(reactor->epoll_fd, reactor->events, MAX_EVENTS, -1);
        if (nfds == -1) {
            perror("epoll_wait");
            exit(EXIT_FAILURE);
        }
        for (int i = 0; i < nfds; i++) {
            int fd = reactor->events[i].data.fd;
            reactor->handlers[fd].handler(fd);
        }
    }
}

void example_handler(int fd) {
    char buf[1024];
    int n = read(fd, buf, sizeof(buf));
    if (n > 0) {
        printf("Read %d bytes: %s", n, buf);
    }
}

int main() {
    Reactor reactor;
    init_reactor(&reactor);
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    register_handler(&reactor, fd, example_handler);
    run_reactor(&reactor);
    return 0;
}

应用场景

Reactor 模型适用于需要处理大量并发连接的场景，如Web服务器、聊天服务器等。它通过事件驱动的方式，有效地利用系统资源，提高系统的响应速度和处理能力。

Proactor 模型

原理

Proactor 模型是一种异步事件驱动的设计模式，与 Reactor 模型不同，Proactor 模型将事件的检测和事件的处理都交给操作系统来完成。Proactor 模型的主要组件包括：

Proactor：负责异步操作的初始化和结果的分发。
Asynchronous Operation Processor：异步操作处理器，负责执行异步操作。
Completion Handler：完成处理器，负责处理异步操作的结果。

工作流程

初始化：创建 Proactor 实例，注册完成处理器。
异步操作：Proactor 发起异步操作，由操作系统执行。
结果检测：操作系统完成异步操作后，通知 Proactor。
结果分发：Proactor 将结果分发给相应的完成处理器。
结果处理：完成处理器处理异步操作的结果。

源码分析

以下是一个简单的 Proactor 模型实现示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <aio.h>

typedef struct {
    int fd;
    void (*handler)(int, const char *, ssize_t);
} CompletionHandler;

typedef struct {
    struct aiocb *aio_list[10];
    CompletionHandler handlers[10];
} Proactor;

void init_proactor(Proactor *proactor) {
    memset(proactor, 0, sizeof(Proactor));
}

void register_handler(Proactor *proactor, int fd, void (*handler)(int, const char *, ssize_t)) {
    proactor->handlers[fd].fd = fd;
    proactor->handlers[fd].handler = handler;
}

void start_async_read(Proactor *proactor, int fd, char *buf, size_t size) {
    struct aiocb *aio = (struct aiocb *)malloc(sizeof(struct aiocb));
    memset(aio, 0, sizeof(struct aiocb));
    aio->aio_fildes = fd;
    aio->aio_buf = buf;
    aio->aio_nbytes = size;
    aio->aio_sigevent.sigev_notify = SIGEV_THREAD;
    aio->aio_sigevent.sigev_notify_function = (void (*)(sigval_t))proactor->handlers[fd].handler;
    aio->aio_sigevent.sigev_value.sival_ptr = aio;
    aio_read(aio);
    proactor->aio_list[fd] = aio;
}

void example_handler(int fd, const char *buf, ssize_t n) {
    if (n > 0) {
        printf("Read %zd bytes: %s", n, buf);
    }
}

int main() {
    Proactor proactor;
    init_proactor(&proactor);
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    register_handler(&proactor, fd, example_handler);
    char buf[1024];
    start_async_read(&proactor, fd, buf, sizeof(buf));
    // 等待异步操作完成
    while (1) {
        sleep(1);
    }
    return 0;
}

应用场景

Proactor 模型适用于需要处理大量I/O操作的场景，如文件服务器、数据库服务器等。它通过异步操作的方式，有效地利用系统资源，提高系统的响应速度和处理能力。

根本区别

Reactor 模型和 Proactor 模型的根本区别在于事件的检测和处理方式：

事件检测：
- Reactor：Reactor 模型通过 Demultiplexer 等待事件的发生，事件检测由应用程序负责。
- Proactor：Proactor 模型通过操作系统进行异步操作，事件检测由操作系统负责。
事件处理：
- Reactor：Reactor 模型在事件发生时，将事件分发给相应的事件处理器进行处理。
- Proactor：Proactor 模型在异步操作完成时，将结果分发给相应的完成处理器进行处理。

总结

Reactor 模型和 Proactor 模型都是高效的事件驱动架构，适用于不同的应用场景。Reactor 模型通过事件检测和分发的方式处理并发请求，适用于大量并发连接的场景；而 Proactor 模型通过异步操作的方式处理I/O操作，适用于大量I/O操作的场景。通过源码分析，我们可以更深入地理解这两种模型的实现原理和根本区别。