Linux网络：reactor模型封装epoll：学习笔记2

上篇Linux网络select/poll/epoll：学习笔记1-CSDN博客，简单的介绍了Linux网络通信的简单实现。此篇介绍基于reactor（反应堆）的事件管理思维，在单线程利用，IO多路复用器（epoll)实现TCP连接的百万并发。

1.reactor网络模型是什么？

        reactor网络模型是一种思想：核心是将网络通信的全过程从以往的管理IO的思维方式转变为管理IO事件的思维模式。首先是将网络连接请求（TCP）注册到IO多路复用器（epoll)上，同时为每一个连接请求分配一个可用的fd，注册网络IO事件，当网络事件发生时，调用业务处理逻辑函数（回调函数），直到网络事件状态发生转移时，回调函数结束(水平触发LT相类似)。

2.为啥要有reactor模型？

        个人觉得reactor模型和c++ 类的抽象具有异曲同工之妙。众所周知，在Linux系统下，一切皆文件，然而文件的种类和格式繁多，如果根据文件的种类和格式管理IO的逻辑相当复杂，编写代码困难，不易理解；但是有趣的是这些文件可以分为三大类：可读，可写，可执行。那么我们只需要根据这三种操作进行封装，其他需要用到网络IO的地方只需调用已经封装好的reactor接口(可能需要少量的修改)，然后完成定制其他业务的处理，那么业务开发简单，编程简单，网络性能稳定，强大（在后文将给出测试结果，采用4台虚拟机 ubuntu20.0环境）。

3.reactor优缺点有哪些？ 

       优点：逻辑清晰，编程简单，可复用性高，性能优异；不足：对多核心逻辑复杂的高并发场景不太适用。

4.reactor网络模型代码   

       

        本篇只提供server端代码，客户端需要借助其他工具或者自己编写： 

        专属学习链接：https://xxetb.xetslk.com/s/4cnbDc

#include <sys/socket.h>
#include <errno.h>
#include <netinet/in.h>

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

#include <pthread.h>
#include <sys/poll.h>
#include <sys/epoll.h>
#include <sys/time.h>

//reactor 实际上是一种思想上的更进一步，利用Linux 本身的系统提供的函数
#define BUFFER_LENGTH 512

struct timeval zvoice_lgy;
typedef int (*RCALLBACK)(int fd);

#define TIME_SUB_MS(tv1, tv2)  ((tv1.tv_sec - tv2.tv_sec) * 1000 + (tv1.tv_usec - tv2.tv_usec) / 1000)

int init_server(unsigned short port);

int accept_connect(int fd);

int recv_cb(int fd);

int send_cb(int fd);

int set_event(int fd ,int event,int tag);

struct conn_item{

	int fd;

	char rbuffer[BUFFER_LENGTH];
	int  rlen;

	char wbuffer[BUFFER_LENGTH];
	int  wlen;

	union{//链接和接收只能同时发生一个
		RCALLBACK accept_callback;
		RCALLBACK recv_callback;

	}recv_t;
	RCALLBACK send_callback;
	
	
};

int epfd =0;

struct conn_item connlist[1048576]={0};


int main(){

	int nport=20;
	unsigned short port = 2048;
	epfd =epoll_create(1);

	for(int i=0;i<nport;i++){
		int sockfd=init_server(port+i);//一个端口只能绑定一个客户端？
		connlist[sockfd].fd=sockfd;
		connlist[sockfd].recv_t.accept_callback=accept_connect;
		set_event(sockfd, EPOLLIN, 1);
		
	}
	
	gettimeofday(&zvoice_lgy, NULL);
	struct epoll_event events[128] = {0};

	while(1){
		
		int nready =epoll_wait(epfd,events,1024,-1);

		for(int i=0;i<nready;i++){
			
			int connfd=events[i].data.fd;

			if(events[i].events&EPOLLIN){
				
				//问题在于将sockfd的事件也进行了一次回调，会有一个接收为空字符的消息，
				//这里可以修改union的使用解决
				int count =connlist[connfd].recv_t.recv_callback(connfd);
				//printf("recv count: %d <-- buffer: %s\n", count, connlist[connfd].rbuffer);
			
			}
			if(events[i].events&EPOLLOUT){

			   //printf("send --> buffer: %s\n",  connlist[connfd].wbuffer);
			   int count =connlist[connfd].send_callback(connfd);
			   //printf("send --> buffer: %s\n",  connlist[connfd].wbuffer);
			}
		}


	}
	
	//close(fd);

}


int init_server(unsigned short port){

	int sockfd =socket(AF_INET,SOCK_STREAM,0);

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

	serveraddr.sin_family=AF_INET;
	serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
	serveraddr.sin_port=htons(port);
	if(-1==bind(sockfd,(struct sockaddr*)&serveraddr,sizeof(struct sockaddr))){
		perror("bind error");
		return -1;
	}

	listen(sockfd,10);

	return sockfd;
}

int set_event(int fd ,int event,int tag){

	if(tag){
		struct epoll_event ev;
		ev.events=event;
		ev.data.fd=fd;
		epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev);
	}else{
		struct epoll_event ev;
		ev.events=event;
		ev.data.fd=fd;
		epoll_ctl(epfd,EPOLL_CTL_MOD,fd,&ev);//not del?
	}
	return 0;	
}

int event_register(int fd ,int event){
    
    if(fd <0)return -1;

    connlist[fd].fd=fd;
	
	memset(connlist[fd].rbuffer, 0, BUFFER_LENGTH);
	connlist[fd].rlen = 0;
	memset(connlist[fd].wbuffer, 0, BUFFER_LENGTH);
	connlist[fd].wlen = 0;

	connlist[fd].recv_t.recv_callback=recv_cb;
	connlist[fd].send_callback=send_cb;

    set_event( fd, event, 1);
}


int accept_connect(int fd){

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

	int clientfd=accept(fd,(struct sockaddr *)&clientaddr,&len);

	if(clientfd<0){
       // printf("accept errno: %d --> %s\n", errno, strerror(errno));
		return -1;
	}
    event_register(clientfd,EPOLLIN);

	if ((clientfd % 1000) == 999) {

	    struct timeval tv_cur;
	    gettimeofday(&tv_cur, NULL);
	    int time_used = TIME_SUB_MS(tv_cur, zvoice_lgy);
	    memcpy(&zvoice_lgy, &tv_cur, sizeof(struct timeval));
    
	    printf("fd : %d, time_used: %d\n", clientfd, time_used);
	}

	return clientfd;
	
}

int recv_cb(int fd){//需要注意的是每个连接端口对应一个fd

	
	memset(connlist[fd].rbuffer,0,BUFFER_LENGTH);

	int count=recv(fd,connlist[fd].rbuffer,BUFFER_LENGTH,0);
	//printf("count : %d",count);

	if(count ==0){

        //printf("client disconnect: %d\n", fd);
		//printf("disconnect\n");
        close(fd);
		epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);
	
		
		return 0;
	}else if(count<0){
        //printf("count: %d, errno: %d, %s\n", count, errno, strerror(errno));
		close(fd);
		epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);

		return 0;
    }

	connlist[fd].rlen = count;	

	memcpy(connlist[fd].wbuffer, connlist[fd].rbuffer, connlist[fd].rlen);
	//memcpy(connlist[fd].wbuffer, connlist[fd].rbuffer, count);
	
	connlist[fd].wlen = connlist[fd].rlen;
	


	set_event(fd, EPOLLOUT, 0);

	
	return count;
}

int send_cb(int fd){

	char *buffer = connlist[fd].wbuffer;
	int wlen= connlist[fd].wlen;

	int count = send(fd, buffer, wlen, 0);

	set_event(fd, EPOLLIN, 0);

	return count;
}

5.测试环境

        四台虚拟机ubuntu20.0，服务端内存8G，客户端4G，测试过程会出现一些问题。可以自行上网查询答案，或者可以一起探讨。

6.百万并发的测试结果