reactor模型实现

最新推荐文章于 2024-07-16 15:44:30 发布
最新推荐文章于 2024-07-16 15:44:30 发布
阅读量840 收藏 4
点赞数 1
分类专栏： 网络编程 C/C++ 文章标签： 网络 c++ socket epoll reactor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QQ1COM12345/article/details/122143328
版权
本文深入解析了Reactor模型，这是一种高效的事件处理模型，常用于高并发服务器。文章详细介绍了Reactor的主要组件，包括多路复用器、事件分发器和事件处理器，并通过具体的C代码实例展示了Reactor模型的使用步骤，包括事件注册、事件处理回调函数等。最后，文章指出Reactor模型在nginx、memcached和redis等开源软件中的应用，并强调其在支持C1000K并发连接方面的优势。
摘要由CSDN通过智能技术生成

文章目录

前言

对于一个服务器而言：网络 IO通常会涉及到两个系统对象，一个是用户空间的调用IO的进程或者线程，另一个是内核空间。比如发生IO操作的read时，通常会经历两个阶段：等待数据准备就绪，将数据从内核空间拷贝到用户的进程或者线程中。所以多种网络IO的模型就此产生。具体介绍可以看上篇文章IO介绍。
对于高并发编程，通常把（等待消息准备好，消息处理）两个阶段分开处理，以下篇幅将介绍一种高效的事件处理模型：Recotor。

提示：以下是本篇文章正文内容

一、什么是reactor模型

Reactor的中文释义是”反应堆“。它的中心思想是将所有要处理的IO事件注册到一个中心IO多路复用器上，同时主线程或者进程阻塞等到复用器上的IO时间，一但IO事件到来或者准备就绪（socket可读，可写，异常等等 ），多路复用器返回并将事先注册的相应IO事件分发到对应的处理器中。

Reactor主要的组件：

  1. 多路复用器：根据不同的操作系统，选用select poll epoll等系统调用（linux三个都支持 ，windows、mac只支持select)。
  2. 事件分发器：将多路复用器中返回的就绪事件分到对应的处理函数中。
  3. 事件处理器：负责处理特定事件的处理函数。

在这里插入图片描述
Reactor具体使用流程 ：

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

二、使用步骤

1.声明一个reactor结构体

代码如下（示例）：

struct ntyreactor {
	int epfd;
	struct ntyevent *events;
};

epfd：epoll的文件描述符，用来操作epoll的接口。
events：reactor管理IO连接的描述符和对应的状态和相应的处理事件的回调函数，定义如下

struct ntyevent {
	int fd;
	int events;
	void *arg;
	int (*callback)(int fd, int events, void *arg);
	
	int status;
	char buffer[BUFFER_LENGTH];
	int length;
	long last_active;
};

主要的成员变量是fd、events、callback。这三个参数分辨对应着IO的socketfd，监听的事件，以及对应处理事件的回调函数。

2.事件的设置，添加，以及删除

代码如下（示例）：

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) {

	struct epoll_event ep_ev = {0, {0}};
	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;
	}

	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_ev = {0, {0}};

	if (ev->status != 1) {
		return -1;
	}

	ep_ev.data.ptr = ev;
	ev->status = 0;
	epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, &ep_ev);

	return 0;
}

2.read，write，accept的事件的处理回调函数

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;

}

3.初始化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;
	}

	reactor->events = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
	if (reactor->events == NULL) {
		printf("create epfd in %s err %s\n", __func__, strerror(errno));
		close(reactor->epfd);
		return -3;
	}
}

4.将监听fd加入到reactor

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]);

	return 0;
}

5.等待事件

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_EVENTS+1];
	
	int checkpos = 0, i;

	while (1) {

		long now = time(NULL);
		for (i = 0;i < 100;i ++, checkpos ++) {
			if (checkpos == MAX_EPOLL_EVENTS) {
				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]);
			}
		}


		int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_EVENTS, 1000);
		if (nready < 0) {
			printf("epoll_wait error, exit\n");
			continue;
		}

		for (i = 0;i < nready;i ++) {

			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);
			}
			
		}

	}
}

6.主函数

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;
}

三、代码解读

  1. main函数开始调用了init_sock，这个函数里面主要是调用了socket()、bind()、listen()监听三件套。生成一个listenfd并返回给main函数。
  2. 第二步初始化了一个reactor。显示调用epoll_create创建一个epoll多路复用器，然后初始化ntyevent的数组，大小为MAX_EPOLL_EVENTS。
  3. 第三步将listenfd添加到reactor里面管理。首先调用nty_event_set，将监听的fd、对应的回调函数accept_cb（因为listenfd负责的是accept）赋值。然后调用nty_event_add，设置evens，也就是要监听的事件（EPOLLIN)复制到对应的ntyevent上，调用epoll_ctl将这个listenfd添加到epoll里面进行对网络IO的监听。
  4. 第四步ntyreactor_run函数，里面主要就是调用多路复用器epoll_wait()等待IO事件的到来，然后处理IO事件，并根据不同的事件（EPOLLIN或者EPOLLOUT)调用注册到ntyevent上的不同的回调函数。比如对于一个EPOLLIN的IO事件，listenfd和connfd的回调处理函数是不一样的（listenfd是accept_cb，clientfd是recv_cb）。
  5. 当一个新的连接进来时，事件分发器调用accept_cb，通过accept（）函数返回一个clientfd，并将clientfd通过nty_event_set、nty_event_add注册到reactor上。并将监听事件初始化为EPOLLIN。
  6. 当 收到一条clientfd消息时，回调recv_cb事件处理器，接收数据。然后把这个clientfd设置可写事件，主要是为了测试可写事件的回调。
  7. 当clientfd可写时，回调send_cb事件处理器，发送消息，并且通过nty_event_del删除事件，避免一直回调可写事件。然后重新注册可读事件。
  8. 为什么要把socketfd设置成非阻塞的？因为有可能在事件处理器中很有可能导致条件不满足时，线程又进入了睡眠等待状态。

总结

上面说Reactor模型中的三个重要组件：

  1. 多路复用器：上述代码对应着的epoll。
  2. 事件分发器：也就是ntyreactor_run函数，将多路复用器中返回的就绪事件分发到注册到对应事件上的事件处理器上。
  3. 事件处理器：accept_cb 、recv_cb 、send_cb三个事件处理器分别对应处理新建连接事件，读事件和写事件。

Reactor模型在很多开源软件中都有应用：nginx、memcached、redis等。之所以其能作为重要的、高效的事件处理模型。原因是其能支持百万并发，也就是C1000K。后面的文章将介绍如何使用Reactor模型支持百万并发，以及如何在Reactor模型上实现一个http服务器。

秃头胖胖怪
关注
专栏目录
reactor java实现_Reactor 模式的简单实现
weixin_28728279的博客
02-13 625
标签：Reactor 模式简单实现在网上有部分文章在描述Netty时，会提到Reactor。这个Reactor到底是什么呢？为了搞清楚Reactor到底是什么鬼，我写了一个简单的Demo，来帮助大家理解他。网上是这么描述Reactor的：The Reactor design pattern handles service requests that are delivered concurrent...
Reactor 模型详解
m0_73088370的博客
08-11 218
Reactor模型具有如下优点响应速度快，不必为单个同步事件所阻塞，因为是事件轮询机制可以最大程度的避免复杂的多线程及同步问题，并且避免了多线程/进程的切换开销扩展性好，可以方便的通过增加Reactor实例个数来充分利用CPU资源复用性好，Reactor模型本身与具体事件处理逻辑无关，具有很高的复用性Reactor模型具有如下缺点相比传统的简单模型，Reactor增加了一定的复杂性，因而有一定的门槛，并且不易于调试。...
【Reactor模型】事件驱动模型 - Reactor模型简述
最新发布
qq_38089448的博客
07-16 260
抛出一个问题：线程怎样才能高效地处理多个连接的业务？当一个连接对应一个线程时，线程一般采用[read->业务处理->send]的处理流程，如果当前连接没有数据可读，那么线程会阻塞到read操作上(socket默认情况是阻塞IO),不过这种阻塞方式并不影响其他线程。但是引入线程池，一个线程需要处理多个连接的业务，线程在处理某个连接的read的操作时，如果遇到没有数据可读，就会发生阻塞，那么线程就没办法继续处理其他的业务。
reactor模式源码
09-16
c++高并发模式的reactor模式，其主要作用就是在接收信息之后在线程池中进行选择空闲线程进行处理
Reactor线程模型的实现
Java技术
11-18 664
一、Selector&Channel 1.1：各种channel 写这个模型需要提前了解Selector以及Channel，之前记录过FileChannel，除此之外还有以下几种Channel： ServerSocketChannel：用于监听新的TCP连接的通道，负责读取&响应，通常用于服务端的实现。 SocketChannel：用于发起TCP连接，读写网络中的数据，通常用于客户端的实现。 DatagramChannel：上述两个通道基于TCP传输协议，而这个通道则基于UDP，用于读写网络
Reactor模式详解＋源码实现
闪电小子
06-04 1678
1.Reactor模式介绍 Reactor模式是事件驱动模型，有一个或多个并发输入源，有一个Service Handler，有多个Request Handlers；这个Service Handler会同步的将输入的请求（Event）多路复用的分发给相应的Request Handler。从结构上，这有点类似生产者消费者模式，即有一个或多个生产者将事件放入一个Queue中，而一个或多个消费者主动的从...
Reactor 模式的简单实现
notOnlyRush的博客
04-04 946
在网上有部分文章在描述Netty时，会提到Reactor。这个Reactor到底是什么呢？为了搞清楚Reactor到底是什么鬼，我写了一个简单的Demo，来帮助大家理解他。   网上是这么描述Reactor的： The Reactor design pattern handles service requests that are delivered concurrently t
Reactor响应模型与实现方式
None
08-21 214
*本文为「码上观世界」原创内容今日爆料：杭州有家叫某鸭的上市公司，在猎头圈被称做抠鸭，看名字就知道在候选人心目中的形象了。不仅如此，某鸭的面试时间经常安排在饭点（11点）；还不顾大多数互...
epoll的reactor模型实现
04-20
Reactor 模型开发效率上比起直接使用 IO 复用要高，它通常是单线程的，设计目标是希望单线程使用一颗 CPU 的全部资源，但也有附带优点，即每个事件处理中很多时候可以不考虑...并最后通过程序演示了reactor模型的结果。
java基于NIO实现Reactor模型源码.zip
06-01
java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现...
Reactor反应器的实现方法详解
12-31
大多数应用都会使用ACE_Reactor::instance()提供的默认反应器实例。但是你也可以选择自己的反应器，这是因为ACE使用了Bridge模式（使用两个不同的类：一个是编程接口，另一个是实现，第一个类会把各个操作传给第二个类）。例如使用线程池反应器实现：ACE_TP_Reactor* tp_reactor = new ACE_TP_Reactor;ACE_Reactor* my_reactor = new ACE_Reactor(tp_reactor, 1);//1表示my_reactor销毁时也要删除tp_reactorACE_Reactor::instance(my_reacto
reactor:NIO 编程模型 - Reactor，各版本实现
05-29
Reactor 模型的说明： Getting started 编译 javac -encoding utf-8 *.java 运行 java Reactor java MultiReactor 测试 使用 telnet 命令进行测试，在 windows 下记得打开回显（ctrl+] -> set localecho -> Enter） ...
Netty高性能之Reactor模型
Linuxhus的博客
09-28 1768
服务端用于接收客户端连接的不再是1个单独的NIO线程，而是一个独立的NIO线程池。网络I/O读、写操作等由一个 NIO 线程池负责，线程池可以采用标准的 JDK 线程池实现（Netty 扩展了 JDK 线程池），它包含一个任务队列和 N 个可用的线程，由这些 NIO 线程负责消息的读取、解码、编码和发送；Acceptor 线程池只用于客户端的登录、握手和安全认证，一旦链路建立成功，就将链路注册到后端 subReactor 线程池的 I/O 线程上，有 I/O 线程负责后续的 I/O 操作。
C++中的Reactor原理与实现
m0_58687318的博客
08-31 1158
中心思想是将所有要处理的I/o事件注册到一个中心I/o多路复用器上，同时主线程/进程阻塞在多路复用器上;reactor设计模式是event-driven architecture的一种实现方式，处理多个客户端并发的向服务端请求服务的场景，每种服务在服务端可能由多个方法组成，这篇文章主要介绍了Reactor原理与实现,需要的朋友可以参考下。处理机制为：主程序将事件以及对应事件处理的方法在Reactor上进行注册, 如果相应的事件发生，Reactor将会主动调用事件注册的接口，即 回调函数....
网络资源整合:Reactor模式的实现方式
weixin_34008805的博客
11-19 110
Reactor模式是处理并发I/O比较常见的一种模式，用于同步I/O，中心思想是将所有要处理的I/O事件注册到一个中心I/O多路复用器上，同时主线程阻塞在多路复用器上；一旦有I/O事件到来或是准备就绪(区别在于多路复用器是边沿触发还是水平触发)，多路复用器返回并将相应I/O事件分发到对应的处理器中。Reactor是一种事件驱动机制，和普通函数调用的不同之处在于：应用程序不是主...
使用c++实现简单的reactor模式
Kmp算法C语言简单实现
11-22 3355
reactor是一种高效的服务端模式，实质是使用io多路复用，比如select、epoll、poll等，关于epoll和reactor的详细介绍往上也有很多的博文，这里贴出reactor的一篇博客：reactor模型 reactor模型的几种角色： handle 即文件描述符 Synchronous Event Demultiplexer 即IO多路复用 Event Handler 即处理事件的回调函数 Concrete Event Handler 即具体的实现逻辑处理的函数 Ini
高性能IO -Reactor模式的实现
weixin_33795806的博客
04-14 250
2019独角兽企业重金招聘Python工程师标准>>> ...
使用c++简单实现reactor模式
热门推荐
baidu20008的专栏
11-22 1万+
事件驱动模型广泛地应用于高性能的web服务器中。而相对应的事件处理模式，最为典型的就是Reactor模式（中文可以称作“反应器” “反应堆”等等，各种叫法都不一样，估且就使用英文吧，叫它Reactor模式）和Proactor模式(中文也称“主动器” “前摄器”，同前者一样称其为Proactor模式)。其中Reactor模式用于同步I/O，而Proactor运用于异步I/O操作。 在各种书籍上，能
netty如何实现reactor模型?
03-20
Netty通过Selector实现了Reactor模型。Selector是Java NIO中的一个组件，它可以检测到一个或多个通道是否处于可读、可写或者有错误事件等待处理，从而实现了非阻塞IO操作。在Netty中，每个Channel都会被注册到一个Selector上，Selector会不断轮询注册在其上的Channel，如果某个Channel上面发生读或者写事件，这个Channel就处于就绪状态，会被Selector轮询出来，然后通过调用之前绑定在这个Channel上的Handler来处理这些事件，从而实现了非阻塞IO操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值