2.1.2 reactor的原理与实现

已于 2022-09-17 09:05:39 修改
阅读量323 收藏 1
点赞数 3
分类专栏： C/C++后台开发 文章标签： 学习 linux 服务器
于 2022-07-05 11:09:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54135264/article/details/125614182
版权

文章目录

一、reactor模型

(1) 基本原理

Reactor 释义“反应堆”，是一种事件驱动机制，和普通函数调用的不同之处在于：应用程序不是主动的调用某个 API 完成处理，而是恰恰相反，Reactor 逆置了事件处理流程，应用程序需要提供相应的接口并注册到 Reactor 上，如果相应的时间发生，Reactor 将主动调用应用程注册的接口，这些接口又称为“回调函数”。

Reactor 模式是处理并发 I/O 比较常见的一种模式，用于同步 I/O，中心思想是将所有要处理的 I/O 事件注册到一个中心 I/O 多路复用器上，同时主线程/进程阻塞在多路复用器上；一旦有 I/O 事件到来或是准备就绪(文件描述符或socket 可读、写)，多路复用器返回并将事先注册的相应 I/O 事件分发到对应的处理器中

(2) 三个重要组件

Reactor 模型有三个重要的组件：

  • 多路复用器：由操作系统提供，在 linux 上一般是 select, poll, epoll 等系统调用。
  • 事件分发器：将多路复用器中返回的就绪事件分到对应的处理函数中。
  • 事件处理器：负责处理特定事件的处理函数。

(3) 具体流程

  1. 注册读就绪事件和相应的事件处理器；
  2. 事件分离器等待事件；
  3. 事件到来，激活分离器，分离器调用事件对应的处理器；
  4. 事件处理器完成实际的读操作，处理读到的数据，注册新的事件，然后返还控制
    权。

(4) 优点

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

二、具体实现

(1) 结构定义

分别定义了两个结构体，事件结构体 ntyevent ， reactor 结构体 ntyreactor

#define BUFFER_LENGTH 4096 //缓冲区长度
#define MAX_EPOLL_EVENT 1024 // epoll中的事物数量
#define SERVER_PORT 8888 

/*
ntyevent
* fd: 该事件的fd
* events : 对应的事件类型,比如输入输出
* arg : 需要传给回调函数的参数,一般传的是该事件所属reactor的指针void* arg
* int (*callback) : 对应的回调函数指针
* status : 事件是否创建的状态 
* buffer : 事件消息
* length : 消息长度
* last_active : 最后的运行时间
* */
struct ntyevent
{
    int fd;     //事务的fd
    int events; // epoll events类型
    void *arg;  //需要传给回调函数的参数,一般传的是reactor的指针
    int (*callback)(int fd, int events, void *arg); //对应的回调函数
    int status; // 0:新建 1：已存在
    char buffer[BUFFER_LENGTH];
    int length;
    long last_active;
};

/*
ntyreactor（通过reactor来管理所有的事件）
* 该reactor的fd
* 该reactor内部的ntyevent数组==*events==（运行时通过epoll_wait取出所有存在内核的事件）
*/
struct ntyreactor
{
    int epfd;                // reatctor的fd
    struct ntyevent *events; // reactor管理的基础单元
};

(2) 事件的设置、添加、删除

int recv_cb(int fd, int events, void *arg);
int send_cb(int fd, int events, void *arg);
int accpet_cb(int fd, int events, void *arg);

void nty_event_set(struct ntyevent *ev, int fd, NCALLBACK callback, void *arg);
int nty_event_add(int epfd, int events, struct ntyevent *ev);
int nty_event_del(int epfd, struct ntyevent *ev);

//设置ntyevent的参数
void nty_event_set(struct ntyevent *ev, int fd, NCALLBACK callback, void *arg)
{
    ev->fd = fd;
    ev->callback = callback;
    ev->events = 0;
    ev->arg = arg;
    ev->last_active = time(NULL);

    return;
}

//增加或修改
int nty_event_add(int epfd, int events, struct ntyevent *ev)
{
    //使用的是linux内核里的epoll
    struct epoll_event ep_ev = {0, {0}};
    //这一步非常关键传到联合体data的ptr里的是ntyevent指针
    ep_ev.data.ptr = ev;
    ep_ev.events = ev->events = events;
    //判断该事件是否已经添加过
    int op;
    if (ev->status == 1)
    {
        op = EPOLL_CTL_MOD;
    }
    else
    {
        op = EPOLL_CTL_ADD;
        ev->status = 1;
    }
    // epoll_ctl进行对应操作
    if (epoll_ctl(epfd, op, ev->fd, &ep_ev) < 0)
    {
        printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
        return -1;
    }
    return 0;
}

int nty_event_del(int epfd, struct ntyevent *ev)
{
    struct epoll_event ep_dv = {0, {0}};
    if (ev->status != 1)
    {
        return -1;
    }
    ep_dv.data.ptr = ev;
    ev->status = 0;
    epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, &ep_dv);

    return 0;
}

(3) 事件建立连接、收消息、发消息的回调函数

int recv_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = reactor->events+fd;

	int len = recv(fd, ev->buffer, BUFFER_LENGTH, 0);
	nty_event_del(reactor->epfd, ev);

	if (len > 0) {
		
		ev->length = len;
		ev->buffer[len] = '\0';

		printf("C[%d]:%s\n", fd, ev->buffer);

		nty_event_set(ev, fd, send_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLOUT, ev);
		
		
	} else if (len == 0) {

		close(ev->fd);
		printf("[fd=%d] pos[%ld], closed\n", fd, ev-reactor->events);
		 
	} else {

		close(ev->fd);
		printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
		
	}

	return len;
}


int send_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = reactor->events+fd;

	int len = send(fd, ev->buffer, ev->length, 0);
	if (len > 0) {
		printf("send[fd=%d], [%d]%s\n", fd, len, ev->buffer);

		nty_event_del(reactor->epfd, ev);
		nty_event_set(ev, fd, recv_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLIN, ev);
		
	} else {

		close(ev->fd);

		nty_event_del(reactor->epfd, ev);
		printf("send[fd=%d] error %s\n", fd, strerror(errno));

	}

	return len;
}

int accept_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	if (reactor == NULL) return -1;

	struct sockaddr_in client_addr;
	socklen_t len = sizeof(client_addr);

	int clientfd;

	if ((clientfd = accept(fd, (struct sockaddr*)&client_addr, &len)) == -1) {
		if (errno != EAGAIN && errno != EINTR) {
			
		}
		printf("accept: %s\n", strerror(errno));
		return -1;
	}

	int i = 0;
	do {
		
		for (i = 3;i < MAX_EPOLL_EVENTS;i ++) {
			if (reactor->events[i].status == 0) {
				break;
			}
		}
		if (i == MAX_EPOLL_EVENTS) {
			printf("%s: max connect limit[%d]\n", __func__, MAX_EPOLL_EVENTS);
			break;
		}

		int flag = 0;
		if ((flag = fcntl(clientfd, F_SETFL, O_NONBLOCK)) < 0) {
			printf("%s: fcntl nonblocking failed, %d\n", __func__, MAX_EPOLL_EVENTS);
			break;
		}

		nty_event_set(&reactor->events[clientfd], clientfd, recv_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLIN, &reactor->events[clientfd]);

	} while (0);

	printf("new connect [%s:%d][time:%ld], pos[%d]\n", 
		inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), reactor->events[i].last_active, i);

	return 0;

}

(4) socket初始化

int init_sock(short port)
{
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    fcntl(fd, F_SETFL, O_NONBLOCK);

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(port);

    bind(fd, (struct sockaddr *)&server_addr, sizeof(server_addr));

    if (listen(fd, 20) < 0)
    {
        printf("listen failed : %s\n", strerror(errno));
    }

    return fd;
}

(5) reactor 初始化

int ntyreactor_init(struct ntyreactor *reactor)
{
    if (reactor == NULL)
    {
        return -1;
    }
    memset(reactor, 0, sizeof(struct ntyreactor));
    //创建大房子
    reactor->epfd = epoll_create(1);
    if (reactor->epfd <= 0)
    {
        printf("create epfd in %s err %s\n", __func__, strerror(errno));
        return -2;
    }
    //申请events的空间
    reactor->events = (struct ntyevent *)malloc((MAX_EPOLL_EVENT) * sizeof(struct ntyevent));
    if (reactor->events == NULL)
    {
        printf("create epfd in %s err %s\n", __func__, strerror(errno));
        close(reactor->epfd);
        return -3;
    }
}

int ntyreactor_destroy(struct ntyreactor *reactor)
{
    close(reactor->epfd);
    //释放调之前malloc的所有资源
    free(reactor->events);
}

(6) 添加listen

//添加最早的回调函数
int ntyreactor_addlistener(struct ntyreactor *reactor, int sockfd, NCALLBACK *acceptor)
{
    if (reactor == NULL)
    {
        return -1;
    }
    if (reactor->events == NULL)
    {
        return -1;
    }

    nty_event_set(&reactor->events[sockfd], sockfd, acceptor, reactor);
    nty_event_add(reactor->epfd, EPOLLIN, &reactor->events[sockfd]);
}

(7) reactor循环

int ntyreactor_run(struct ntyreactor *reactor)
{
    if (reactor == NULL)
        return -1;
    if (reactor->epfd < 0)
        return -1;
    if (reactor->events == NULL)
        return -1;

    struct epoll_event events[MAX_EPOLL_EVENT + 1];
    int checkpos = 0, i;

    while (1)
    {
        // 100个为单位的进行检查是否超时
        long now = time(NULL);
        for (int i = 0; i < 100; i++, checkpos++)
        {
            //满了就清空
            if (checkpos == MAX_EPOLL_EVENT)
            {
                checkpos = 0;
            }
            //未创建跳过
            if (reactor->events[checkpos].status != 1)
            {
                continue;
            }
            //检测连接时间太长了就断掉
            long duration = now - reactor->events[checkpos].last_active;

            if (duration >= 60)
            {
                close(reactor->events[checkpos].fd);
                printf("[fd=%d] timeout\n", reactor->events[checkpos].fd);
                nty_event_del(reactor->epfd, &reactor->events[checkpos]);
            }
        }

        //从内核中把事务提取出来放到events里面
        int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_EVENT, 1000);
        if (nready < 0)
        {
            printf("epoll_wait error, exit\n");
            continue;
        }

        //最最最关键的地方实现回调函数
        for (i = 0; i < nready; i++)
        {
            //这里data是一个union传过来的就只有之前放进去的指向ntyevent的指针
            struct ntyevent *ev = (struct ntyevent *)events[i].data.ptr;

            if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN))
            {
                ev->callback(ev->fd, events[i].events, ev->arg);
            }
            if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT))
            {
                ev->callback(ev->fd, events[i].events, ev->arg);
            }
        }
    }
}

(8) main函数

int main(int argc, char *argv[]) {

	unsigned short port = SERVER_PORT;
	
	if (argc == 2) {
		port = atoi(argv[1]);
	}
	
	int sockfd = init_sock(port);

	struct ntyreactor *reactor = (struct ntyreactor*)malloc(sizeof(struct ntyreactor));
	ntyreactor_init(reactor);
	
	ntyreactor_addlistener(reactor, sockfd, accept_cb);
	ntyreactor_run(reactor);

	ntyreactor_destory(reactor);
	close(sockfd);
	

	return 0;
}

三、编译与调试

  • Ubuntu 14.04—server
  • gcc -o reactor reactor.c
  • 运行服务器并使用网络调试助手调试
Crazy_张老板
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
H5player-2.1.2
12-29
H5player_2.1.2
MIPCMS内容管理系统 V2.1.2
11-28
MIPCMS是一套开源的基于百度移动加速器MIP引擎基础上而开发的文章、资讯、内容管理系统，同时该系统也为互联网、创业者等群体打造的SEO优化后的建站系统。MIPCMS适合个人博
reactor原理
3月24日白羊座的博客
05-23 433
Reactor 释义“反应堆”，是一种事件驱动机制。 把epoll的事件处理流程逆置，把对应的回调函数注册到Reactor，当事件发生时，Reactor调用回调函数函数。 Reactor 模式是处理并发 I/O 比较常见的一种模式，用于同步 I/O，中心思想是: 1.先注册的相应 I/O 事件分发到对应的处理器中 2.将所有要处理的 I/O 事件注册到一个中心 I/O 多路复用器上，同时主线程/进程阻塞在多路复用器上； 3.一旦有 I/O 事件到来，多路复用器从事件处理器获取相应函数调用 接下来从epol
reactor 原理
SAN_YUN的专栏
01-03 278
参考论文  
reactor的原理与实现
congchp的博客
08-25 737
reactor模式是对epoll的一层封装，将网络io转换成event。redis/nginx/libevent对网络io的处理，都采用了reactor模式。 参考下面的代码, 看完这段代码就会明白什么是reactor #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #inc
antSword-2.1.2
05-01
antSword-2.1.2
LwIP源码V2.1.2
10-16
LwIP源码V2.1.2.该源码为目前最新版。LwIP为轻量级的网络通讯代码，适合嵌入式系统进行移植。
Nacos2.1.2适配达梦8数据库
10-21
nacos2.1.2修复上一个版本中注册服务及配置无分页功能 增加国产数据库达梦8的适配 需在conf/application.properties 文件中更新数据库配置，配置如下： db.jdbcDriverName=dm.jdbc.driver.DmDriver db.url.0=jdbc:dm...
Reactor原理与实现
weixin_52259848的博客
06-19 1000
Reactor原理与实现
reactor原理与实现
weixin_42256218的博客
08-07 240
reactor 模型开发效率上比起直接使用 IO 复用要高，它通常是单线程的，设计目标是希望单线程使用一颗 CPU 的全部资源，但也有附带优点，即每个事件处理中很多时候可以不考虑共享资源的互斥访问。可是缺点也是明显的，现在的硬件发展，已经不再遵循摩尔定律，CPU 的频率受制于材料的限制不再有大的提升，而改为是从核数的增加上提升能力，当程序需要使用多核资源时，reactor 模型就会悲剧, 为什么呢？
高性能网络模式：Reactor 的原理与思考
weixin_44545838的博客
06-05 660
Reactor 模式和 Proactor 模式都是处理并发 I/O 事件的设计模式。它们各自的核心思想是将 I/O 操作与实际处理逻辑解耦。本文将详细介绍高性能网络模式**：Reactor 和 Proactor 的原理**，并通过 C++ 代码示例来展示它们的实现。我们将深入探讨这两种模式的优缺点，以及如何在实际项目中应用它们。Proactor模式是一种基于事件驱动的网络编程模式。
深入理解Reactor模型的原理与应用
djh的博客
08-27 1305
Reactor意思是“反应堆”，是一种事件驱动机制。 和普通函数调用的不同之处在于：应用程序不是主动的调用某个 API 完成处理，而是恰恰相反，Reactor逆置了事件处理流程，应用程序需要提供相应的接口并注册到 Reactor 上，如果相应的时间发生，Reactor将主动调用应用程序注册的接口，这些接口又称为“回调函数”。
Reactor线程模型【原理笔记】
gaoliang1719的专栏
06-13 292
前言Reactor模型是基于事件驱动的线程模型，可以分为Reactor单线程模型、Reactor多线程模型、主从Reactor多线程模型，通常基于在I/O多路复用实现。不同的角色职责有：...
Reactor与NIO底层原理及上层实现原理
Littlemotor
02-28 679
一篇文章读懂阻塞，非阻塞，同步，异步 https://www.jianshu.com/p/b8203d46895c IO多路复用的三种机制Select，Poll，Epoll https://www.jianshu.com/p/397449cadc9a Java NIO、Reactor、Netty https://blog.csdn.net/ZXW601498616/article/det...
Reactor的原理与实现
成长历程记录
12-29 681
Reactor释义“反应堆”，是一种事件驱动机制。和普通函数调用的不同之处在于：应用程序不是主动的调用某个API完成处理，而是恰恰相反，Reactor逆置了事件处理流程，应用程序需要提供相应的接口并注册到Reactor上，如果相应的事件发生，Reactor将主动调用应用程序注册的接口，这些接口又称为“回调函数”。 Reactor模式是处理并发IO比较常见的一种模式，用于同步IO，中心思想是将所有要处理的IO事件注册到一个中心IO多路复用器上，同时主线程/进程阻塞在多路...
Reactor模式简单实现与理解
fdsfdf3434的博客
11-28 4513
Class Reactor:/** * * 经典的网络服务在每个线程中完成对数据的处理： * 但这种模式在用户负载增加时，性能将下降非常的快。 * 系统运行的性能瓶颈通常在I/O读写，包括对端口和文件的操作上，过去，在打 开一个I/O通道后， * read()将一直等待在端口一边读取字节内容，如果没有内容进来，read()也是傻傻的等， * 这会影响我们程序继续做其他事情，那 么改进
服务器Reactor架构浅析
夜夜夜夜
12-20 4289
Reactor模式是一个架构模式，它主要解决的问题是高并发场景下的服务器的性能问题。原来的服务器与客户端的链接是一对一的，也就是说一个客户端socket接到后，对应一个线程去接收和处理，这种模式的好处，是思路很清晰，一个线程处理一个socket请求，但是这种太消耗线程资源，因为毕竟socket不是实时都有数据接入的。例如网卡属于是典型的慢速设备，因此，如何能高效的利用一些模式，可以改变这种局面，这个
lwip2.1.2 f767
最新发布
11-09
通过lwip2.1.2，我们可以轻松地实现与网络相关的应用，例如通过TCP/IP协议进行远程控制、数据传输等。 STM32F767微控制器具有强大的性能和丰富的外设资源，使用lwip2.1.2版本可以更好地发挥其网络通信能力。而且，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值