reactor原理

最新推荐文章于 2024-03-21 09:41:17 发布
最新推荐文章于 2024-03-21 09:41:17 发布
阅读量441 收藏
点赞数
分类专栏： 服务器开发 文章标签： linux 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40908979/article/details/116573807
版权

Reactor 释义“反应堆”，是一种事件驱动机制。
把epoll的事件处理流程逆置，把对应的回调函数注册到Reactor，当事件发生时，Reactor调用回调函数函数。
在这里插入图片描述

Reactor 模式是处理并发 I/O 比较常见的一种模式，用于同步 I/O，中心思想是:
1.先注册的相应 I/O 事件分发到对应的处理器中
2.将所有要处理的 I/O 事件注册到一个中心 I/O 多路复用器上，同时主线程/进程阻塞在多路复用器上；
3.一旦有 I/O 事件到来，多路复用器从事件处理器获取相应函数调用

接下来从epoll的基础上逐步实现reactor
网络IO模型上一次代码的基础上把处理事件的部分改为回调函数

epoll_data是联合体，只能选择一种数据，那么我们既要socketfd也要回调函数就需要用到该联合体的ptr指针

typedef union epoll_data
{
  void *ptr;				//自定义数据
  int fd;					//保存socket
  uint32_t u32;
  uint64_t u64;
} epoll_data_t;

新建一个结构体存储到ptr就可以了

struct sockitem {
	int sockfd;					//event的fd
	int (*callback)(int fd, int events, void *arg);		//event的回调函数
};

代码

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

#include <netinet/tcp.h>
#include <arpa/inet.h>

#include <errno.h>
#include <sys/epoll.h>

#define BUFFER_LENGTH	1024
#define EPOLL_SIZE		1024

int epoll_fd = 0;
char buffer[BUFFER_LENGTH] = {0};

//socket的数据
struct sockitem {
	int sockfd;
	int (*callback)(int fd, int events, void *arg);
};

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

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

	struct sockitem *si = (struct sockitem*)arg;
	struct epoll_event ev;
	char buf[BUFFER_LENGTH] = {0};

	sprintf(buf,"recv : %s\n", buffer);
	send(fd, buf, BUFFER_LENGTH, 0);
	si->sockfd = fd;
	
	ev.events = EPOLLIN | EPOLLET;
	si->callback = recv_cb;
	ev.data.ptr = si;

	epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &ev);
}

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

	struct sockitem *si = (struct sockitem*)arg;
	struct epoll_event ev;

	int ret = recv(fd, buffer, BUFFER_LENGTH, 0);
	if (ret < 0) {
		if (errno == EAGAIN || errno == EWOULDBLOCK) {
			printf("read all data");
		}
		close(fd);
		
		ev.events = EPOLLIN;
		epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &ev);
		free(si);
		return -1;
	} else if (ret == 0) {
		printf(" disconnect %d\n", fd);
		close(fd);
		ev.events = EPOLLIN;
		epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &ev);
		return -1;
	} else {
		printf("Recv: %s, %d Bytes\n", buffer, ret);
		//读完数据后回客户端信息,
		//设置EPOLLOUT让clientfd回信息给客户端
		ev.events = EPOLLOUT | EPOLLET;
		si->sockfd = fd;
		si->callback = send_cb;
		ev.data.ptr = si;
		//把clientfd的事件类型改为EPOLLOUT
		epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &ev);	
	}
}

int accept_cb(int fd, int events, void *arg) {
	struct sockaddr_in client_addr;
	memset(&client_addr, 0, sizeof(struct sockaddr_in));
	socklen_t client_len = sizeof(client_addr);

	int clientfd = accept(fd, (struct sockaddr*)&client_addr, &client_len);
	if (clientfd <= 0) 
		return -1;

	char str[INET_ADDRSTRLEN] = {0};
	printf("recvived from %s at port %d, sockfd:%d, clientfd:%d\n", inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)),
		ntohs(client_addr.sin_port), fd, clientfd);
	
	struct epoll_event ev;

	//设置客户端触发类型EPOLLIN和EPOLLET
	//EPOLLET是每次事件触发一次
	ev.events = EPOLLIN | EPOLLET;
	struct sockitem *si = (struct sockitem*)malloc(sizeof(struct sockitem));
	si->sockfd = clientfd;
	si->callback = recv_cb;
	ev.data.ptr = si;
	epoll_ctl(epoll_fd, EPOLL_CTL_ADD, clientfd, &ev);

	return clientfd;
}

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

	if (argc < 2) {
		printf("Paramter Error\n");
		return -1;
	}
	int port = atoi(argv[1]);

	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (sockfd < 0) {
		perror("socket");
		return -1;
	}

	struct sockaddr_in addr;
	memset(&addr, 0, sizeof(struct sockaddr_in));

	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = INADDR_ANY;

	if (bind(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0) {
		perror("bind");
		return 2;
	}

	if (listen(sockfd, 5) < 0) {
		perror("listen");
		return 3;
	}

	//创建epoll句柄
	epoll_fd = epoll_create(1);
	struct epoll_event ev, events[EPOLL_SIZE] = {0};

	ev.events = EPOLLIN;

	struct sockitem *si = (struct sockitem*)malloc(sizeof(struct sockitem));
	si->sockfd = sockfd;
	si->callback = accept_cb;
	ev.data.ptr = si;
	//添加服务端事件和fd
	epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &ev);
	
	while (1) {

		//等待事件
		int nready = epoll_wait(epoll_fd, events, EPOLL_SIZE, -1);
		if (nready == -1) {
			printf("epoll_wait\n");
			break;
		}

		int i = 0;
		for (i = 0;i < nready;i ++) {
			//EPOLLIN事件
			if (events[i].events & EPOLLIN) {
				struct sockitem *si = (struct sockitem*)events[i].data.ptr;
				si->callback(si->sockfd, events[i].events, si);
			}
			
			//EPOLLOUT事件
			if(events[i].events & EPOLLOUT) {
				struct sockitem *si = (struct sockitem*)events[i].data.ptr;
				si->callback(si->sockfd, events[i].events, si);
			}
		}
	}
}

把epollfd和事件集合定义为一个结构体,socket的结构体再加上缓存区

struct sockitem {
	int sockfd;
	int (*callback)(int fd, int events, void *arg);

	char recvbuffer[BUFFER_LENGTH]; //接收缓存
	char sendbuffer[BUFFER_LENGTH];	//发送缓存
	int rlength;					//接收缓存的长度
	int slength;					//发送缓存的长度
};
struct reactor {

	int epfd;
	struct epoll_event events[512];
	
};

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

#include <unistd.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <pthread.h>

#include <errno.h>
#include <sys/epoll.h>

#define BUFFER_LENGTH		1024

struct sockitem {

	int sockfd;
	int (*callback)(int fd, int events, void *arg);

	char recvbuffer[BUFFER_LENGTH]; //接收缓存
	char sendbuffer[BUFFER_LENGTH];	//发送缓存
	int rlength;					//接收缓存的长度
	int slength;					//发送缓存的长度
	
};

struct reactor {

	int epfd;
	struct epoll_event events[512];
	
};

struct reactor *eventloop = NULL;

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

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

	struct sockitem *si = (struct sockitem*)arg;

	send(fd, si->sendbuffer, si->slength, 0); 

	struct epoll_event ev;
	ev.events = EPOLLIN | EPOLLET;
	si->sockfd = fd;
	si->callback = recv_cb;
	ev.data.ptr = si;

	epoll_ctl(eventloop->epfd, EPOLL_CTL_MOD, fd, &ev);

}

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

	//int clientfd = events[i].data.fd;
	struct sockitem *si = (struct sockitem*)arg;
	struct epoll_event ev;

	//char buffer[1024] = {0};
	int ret = recv(fd, si->recvbuffer, BUFFER_LENGTH, 0);
	if (ret < 0) {

		if (errno == EAGAIN || errno == EWOULDBLOCK) { //
			return -1;
		}

		ev.events = EPOLLIN;
		epoll_ctl(eventloop->epfd, EPOLL_CTL_DEL, fd, &ev);
		close(fd);
		free(si);	

	} else if (ret == 0) {
 
		printf("disconnect %d\n", fd);

		ev.events = EPOLLIN;

		epoll_ctl(eventloop->epfd, EPOLL_CTL_DEL, fd, &ev);
		close(fd);
		free(si);
		
	} else {

		printf("Recv: %s, %d Bytes\n", si->recvbuffer, ret);

		si->rlength = ret;
		memcpy(si->sendbuffer, si->recvbuffer, si->rlength);
		si->slength = si->rlength;

		struct epoll_event ev;
		ev.events = EPOLLOUT | EPOLLET;
		si->sockfd = fd;
		si->callback = send_cb;
		ev.data.ptr = si;

		epoll_ctl(eventloop->epfd, EPOLL_CTL_MOD, fd, &ev);
	}
}


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

	struct sockaddr_in client_addr;
	memset(&client_addr, 0, sizeof(struct sockaddr_in));
	socklen_t client_len = sizeof(client_addr);
	
	int clientfd = accept(fd, (struct sockaddr*)&client_addr, &client_len);
	if (clientfd <= 0) return -1;

	char str[INET_ADDRSTRLEN] = {0};
	printf("recv from %s at port %d\n", inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)),
		ntohs(client_addr.sin_port));

	struct epoll_event ev;
	ev.events = EPOLLIN | EPOLLET;

	struct sockitem *si = (struct sockitem*)malloc(sizeof(struct sockitem));
	si->sockfd = clientfd;
	si->callback = recv_cb;
	ev.data.ptr = si;
	
	epoll_ctl(eventloop->epfd, EPOLL_CTL_ADD, clientfd, &ev);
	
	return clientfd;
}

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

	if (argc < 2) {
		return -1;
	}

	int port = atoi(argv[1]);

	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (sockfd < 0) {
		return -1;
	}

	struct sockaddr_in addr;
	memset(&addr, 0, sizeof(struct sockaddr_in));

	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = INADDR_ANY;

	if (bind(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0) {
		return -2;
	}

	if (listen(sockfd, 5) < 0) {
		return -3;
	}

	eventloop = (struct reactor*)malloc(sizeof(struct reactor));
	memset(eventloop,0,sizeof(struct reactor));

	eventloop->epfd = epoll_create(1);
	
	struct epoll_event ev;
	ev.events = EPOLLIN;
	
	struct sockitem *si = (struct sockitem*)malloc(sizeof(struct sockitem));
	si->sockfd = sockfd;
	si->callback = accept_cb;
	ev.data.ptr = si;
	
	epoll_ctl(eventloop->epfd, EPOLL_CTL_ADD, sockfd, &ev);

	while (1) {

		int nready = epoll_wait(eventloop->epfd, eventloop->events, 512, -1);
		if (nready < -1) {
			break;
		}

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

			if (eventloop->events[i].events & EPOLLIN) {

				struct sockitem *si = (struct sockitem*)eventloop->events[i].data.ptr;
				si->callback(si->sockfd, eventloop->events[i].events, si);
			}

			if (eventloop->events[i].events & EPOLLOUT) {

				struct sockitem *si = (struct sockitem*)eventloop->events[i].data.ptr;
				si->callback(si->sockfd, eventloop->events[i].events, si);
			}
		}
	}
}
3月24日白羊座
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文搞懂Reactor模型与实现
Java技术攻略的博客
03-15 4569
在网络IOReactor模型和Proactor模型。Reactor基于同步IO模式，Proactor基于异步IO模式。Netty网络框架，Redis等中间件中都有使用到Reactor模型。本文将对Reactor模型的如下三种分类进行学习和实现。单Reactor单线程模型；单Reactor多线程模型；主从Reactor多线程模型。Reactor模型主要就是监听事件分发事件和处理事件。其中Reactor角色会负责监听事件和分发事件Handler角色和Acceptor角色会负责处理事件。Reactor。
快速掌握Reactor Core实现响应式编程
neweastsun的专栏
09-28 4538
在本文我们给出Reactive Core概述，并解释了如何发布和订阅流、应用反压、对流进行操作以及异步处理流数据。学习这些内容希望能对你有帮助，为编写响应式应用程序打下基础。
探索Reactor Core：Java中的反应式编程框架
最新发布
gitblog_00018的博客
03-21 454
探索Reactor Core：Java中的反应式编程框架 项目地址:https://gitcode.com/reactor/reactor-core Reactor Core是一个强大的Java库，它为开发者提供了反应式编程模型的支持，这是现代微服务架构中的一种流行范式。由Pivotal开发并维护，它是Spring Framework和Spring Boot生态系统的重要组成部分。本文将深入探讨R...
Reactor模型详解
热门推荐
乐乐的博客
09-30 1万+
文章目录前言一、经典的同步阻塞模型二、单reactor单线程设计1.代码示例三、单reactor多线程设计四、多reactor多线程设计五、Reactor模型结构图总结 前言 说到NIO、Netty，Reactor模型一定是绕不开的，因为这种模式架构太经典了，但是好多人在学习的时候，往往会忽视基础的学习，一上来就是Netty，各种高大上，但是却没有静下心来好好看看Netty的基石——Reactor模型。本文就带着大家看看Reactor模型，让大家对Reactor模型有个浅显而又感性的认识。 一、经典的同
Reactor模型
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
03-31 1万+
Reactor模型，是基于事件驱动的，通过一个或多个输入同时传递给服务端处理 服务端程序处理传入的多个请求，并分发到相应的处理线程
主从reactor多线程实现
12-18
下面我们将深入探讨主从reactor模式的概念、工作原理以及如何在实际项目中实现。 一、主从reactor模式概述 主从reactor模式是一种扩展自单reactor的设计模式，其核心思想是将事件分发和事件处理分离，以提高系统的...
reactor-demo
03-06
本项目"reactor-demo"显然是一个展示Reactor模式的实例，通过分析其源代码，我们可以深入理解Reactor模式的原理和C++实现方式。 首先，Reactor模式的核心思想是将事件分发和事件处理分离。它包含以下几个主要组件：...
pscadexample.1_reactor_
10-04
在电力系统领域，电感器，也称为反应器（Reactor），是一种重要的无源设备，主要用来限制电流、稳定电压以及滤波等。...这不仅有助于理解和掌握反应器的工作原理，还能提高电力系统建模和分析的能力。
reactor-siemens原文和翻译
09-28
这个文件可能包含详细的技术细节，如Reactor模型的工作原理、如何在Siemens的系统中实现、案例研究以及翻译过程中遇到的挑战和可能的误解。 **深入学习方向** 对于想要深入理解Reactor模型和其在Siemens技术中的...
【NIO系列】——之Reactor模型
weixin_34133829的博客
07-11 1310
在开篇之前，我们对JavaNIO 的使用方式不做过多介绍，这种API的介绍方式网上太多了，没必要详细介绍，我们假设NIO的使用方式，你能够熟练运用。这是NIO系列第三篇:【NIO系列】——之TCP探秘【NIO系列】——之IO模型通过之前的Unix的IO模型介绍，想必也了解到了5种IO模型。java的NIO是属于同步非阻塞IO，关于IO多路复用，java没有相应的IO模型，但有相应的编程模式，Rea...
Reactor模型讲解
moneywenxue的博客
09-14 3283
一、什么是Reactor模型 反应器设计模式(Reactor pattern)是一种为处理并发服务请求，并将请求提交到一个或 者多个服务处理程序的事件设计模式。当客户端请求抵达后，服务处理程序使用多路分配策略，由一个非阻塞的线程来接收所有的请求，然后派发这些请求至相关的工作线程进行处理。 关于reactor 是什么，我们先从wiki上看下: The reactor design pattern is an event handling pattern for handling serv...
reactor简单入门
技术专栏
02-10 1365
reactor是一个基于reactive streams的响应式编程框架。在了解project reactor 项目之前， 你需要熟悉观察者模式（订阅发布模式）和reactive streams。只有了解了这些内容，才能更好的开始project reactor的学习。你可以通过看和了简单学习这两个知识点。
Reactor线程模型
沉浸式Study
04-14 1691
doAccept为主要处理连接接收代码, selector接收到客户端请求, 接收到一个SocketChannel, 将其添加到selecor thread(IO检测线程)中, 其中获取selecor thread时采用迭代器实现轮询(round robin)的效果, 目的将SocketChannel平均分配到selecor thread的队列中。在业务线程BusinessHandler中, 反序列化接收到的数据, 处理业务逻辑, 最终在上下文中写出响应数据。变种reactor线程比例。
reactor的原理与实现
congchp的博客
08-25 759
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
reactor原理与实现
weixin_42256218的博客
08-07 281
reactor 模型开发效率上比起直接使用 IO 复用要高，它通常是单线程的，设计目标是希望单线程使用一颗 CPU 的全部资源，但也有附带优点，即每个事件处理中很多时候可以不考虑共享资源的互斥访问。可是缺点也是明显的，现在的硬件发展，已经不再遵循摩尔定律，CPU 的频率受制于材料的限制不再有大的提升，而改为是从核数的增加上提升能力，当程序需要使用多核资源时，reactor 模型就会悲剧, 为什么呢？
(一）Reactor模式详解
小白的成长
07-05 8854
阅读libevent代码版本为1.4.13 stable版本，阅读书籍参考张亮大神libevent源码深度剖析。 在此主要记录自己学习过程中的一些点点滴滴。 阅读之前需要先了解一下5中I/O模型的比较。 Reactor模式 Reactor(反应堆模式)是libevent的中心思想，常规的I/O多路复用中采用select和poll、epoll等来实现。而Reactor是将上述机制进一步封装，通俗的来讲，就是通过回调机制实现。我们只需将事件的接口注册到Reactor上，当事件发生之后，会回调注册的接口。 Re
netty reactor模型 原理
04-25
Netty Reactor模型是基于事件驱动的设计，其原理如下： 1. 在Netty的线程池中，有一个主线程（即Reactor线程），它等待IO事件的发生。 2. 当有IO事件发生时，主线程会把事件放入队列中，并唤醒处理线程。 3. 处理线程从队列中取出事件并处理。 4. 处理完成后，线程将结果返回给客户端。 React模型具有以下优点： 1. 在IO事件的处理中，线程不需要休眠和等待，减少了线程上下文切换的开销。 2. Reactor模型中的线程数相对较少，减少了系统资源的占用。 3. Reactor模型具有良好的扩展性和可维护性，能够满足高并发的需求。 希望这个回答能够对你有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值