【Linux】多路IO复用技术③——epoll详解如何使用epoll模型实现简易的一对多服务器（附图解与代码实现）-编程知识

在正式阅读本篇博客之前，建议大家先按顺序把下面这两篇博客看一下，否则直接来看这篇博客的话估计很难搞懂

多路IO复用技术①——select详解&如何使用select模型在本地主机实现简易的一对多服务器http://t.csdnimg.cn/BiBib多路IO复用技术②——poll详解&如何使用poll模型在本地主机实现简易的一对多服务器http://t.csdnimg.cn/EEzOf

在了解以上两篇博客讲解的内容后，我们正式开始本篇博客的相关内容讲解，第三种多路套接字监听技术——epoll模型

EPOLL模型优化的第一部分

1.对拷贝开销的优化

2.对挂载开销的优化

3.对查找开销的优化

EPOLL模型的相关接口

EPOLL模型优化的第一部分

我们知道，select和poll模型实现的监听原理其实都是按照以下这些步骤：

系统会将这个用户层的监听集合拷贝到内核层
系统会将内核层的该监听集合中监听的套接字放入IO设备等待队列，由IO设备等待队列来进行一次又一次的遍历来判断那些套接字中有数据需要处理
当IO设备等待队列发现有套接字处于就绪状态时，会传出就绪集合到内核层
系统通过select模型将该就绪集合由内核层拷贝到用户层，供用户使用

想要了解下面的内容，这里需要为大家简单讲解一种数据结构——红黑树 ，并希望大家能够记住红黑树的优点

红黑树的优势就在于非常适合用来存储有序的数据，并且增删查改的时间复杂度很低，只有O(log2n)

1.对拷贝开销的优化

在之前的博客中，我们讲过，随着select/poll模型的持续使用，会产生大量的拷贝开销和挂载开销

这些拷贝开销大致由两部分组成：

系统从用户层到内核层，内核层到用户层翻来覆去的层级转换
一旦监听集合更新，就要重新拷贝整个就绪集合，只要服务器不停，就会面临无止尽的拷贝

该如何减少第一部分的拷贝开销呢？

其实很简单粗暴，epoll模型的开发人员直接将监听集合定义在内核层。所以epoll模型的监听集合都是建立在内核层的

PS：这种监听集合实际上是红黑树，每一个叶子节点对应一个监听套接字

至于如何减少第二部分的拷贝开销，就和红黑树树这种数据结构息息相关了。

我们知道，select和poll模型都是采用数组作为作为监听集合，数组这种结构非常不便于查找其中哪些数据产生了变化，就导致当有新的套接字要放入监听集合中时，系统会将整个新的监听集合全部拷贝到内核层。

而红黑树就完美的避开了这一点，每当有新的套接字要放入监听树中时，我们只需要为这棵监听红黑树添加一个叶子节点就够了，而不是重建这棵树，这就导致了这方面的开销大大减少了

2.对挂载开销的优化

在对拷贝开销的优化方面，epoll模型的开发人员依旧采用了红黑树这种数据结构，我们来为大家简单的介绍一下原因：

我们知道，在select与poll模型中，数组这种结构非常不便于查找其中哪些数据产生了变化，所以每当有新的套接字放入监听集合中时，系统会将监听的套接字全部重新挂载到IO设备等待队列，这就导致挂载开销方面的开销非常大。

而红黑树则完美的解决了这个问题，由于红黑树的特性，每当有对应新套接字的叶子节点被放入监听树中时，系统能够很轻松的就能找到对应新套接字的叶子节点是哪一个，然后只需要将对应的新套接字放入IO设备等待队列就可以了，在挂载开销方面的消耗大大减少

3.对查找开销的优化

我们知道，虽然数组的下标是有序的，方便我们进行遍历，但是数组中的内容并不一定是有序的，这就导致我们无法根据我们目标内容来直接找到其在数组中的哪个位置，而是需要去通过循环一次次的查找，但红黑树就完美地解决了这个问题

我们知道，当我们调用accept函数让服务器与多个客户端建立TCP链接时，其返回的int类型的套接字文件描述符，其实都是有序递增的，建立一个链接返回值就+1。由于红黑树在有序数据存储方面的优势，使得服务器在对于监听就绪和取消监听方面的效率非常之高。

其实epoll模型不止在这些方面进行了优化，其他部分需要大家了解了EPOLL模型的相关接口后，才能为大家进行讲解，所以别着急，我们先来了解下EPOLL模型的相关接口吧

EPOLL模型的相关接口

以下接口的头文件都是 #include <sys/epoll.h>

EPOLL模型优化的第二部分

4.监听方面的优化

由于epoll模型的自定义结构体队列、异步通知和回调函数的使用，导致用户不再需要遍历去查找就绪的套接字是哪些，直接对自己在用户层自定义的结构体数组进行遍历处理就可以了，大大减少了时间片方面的消耗，使得服务器的处理能力实现质的飞跃

基本了解了epoll在哪些方面做出了优化后，我们就可以来聊一聊epoll模型的优缺点了

EPOLL模型的优缺点

优点：

不存在重复的拷贝开销与挂载开销

自定义实现监听队列，采用异步回调方式，无需轮询，队列体积更小

不止返回就绪的套接字数量，还返回就绪的套接字是哪些

监听的事件种类丰富

可以为不同的套接字设置不同的监听事件，不像select模型只能批量设置监听事件

可以监听的socket数量不受1024的硬限制

缺点：

仅linux系统支持
红黑树的缺点

使用epoll模型实现简易一对多服务器的程序实现

程序构成

该服务器与客户端由以下几个程序共同组成：

func_2th_parcel.h：定义二次包裹的函数名
func_2th_parcel.c：对网络初始化相关的函数进行二次包裹
epoll_server.c：使用poll模型的服务器程序
client.c：客户端程序

/*************************************************************************> File Name: func_2th_parcel.h> Author: Nan> Mail: **@qq.com> Created Time: 2023年10月18日 星期三 18时32分22秒************************************************************************/#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <signal.h>
#include <pthread.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/mman.h>
#include <time.h>
#include <ctype.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <poll.h>
#include <sys/epoll.h>//socket函数的二次包裹
int SOCKET(int domain , int type , int protocol);//bind函数的二次包裹
int BIND(int sockfd , const struct sockaddr* addr , socklen_t  addrlen);//listen函数的二次包裹
int LISTEN(int sockfd , int backlog);//send函数的二次包裹
ssize_t SEND(int sockfd , const void* buf , size_t len , int flags);//recv函数的二次包裹
ssize_t RECV(int sockfd , void* buf , size_t len , int flags);//connect函数的二次包裹
int CONNECT(int sockfd , const struct sockaddr* addr , socklen_t addrlen);//accept函数的二次包裹
int ACCEPT(int sockfd , struct sockaddr* addr , socklen_t addrlen);//网络初始化函数
int SOCKET_NET_CREATE(const char* ip , int port);//服务端与客户端建立连接并返回客户端套接字文件描述符
int SERVER_ACCEPTING(int server_fd);

/*************************************************************************> File Name: func_2th_parcel.c> Author: Nan> Mail: **@qq.com> Created Time: 2023年10月18日 星期三 18时32分42秒************************************************************************/#include <func_2th_parcel.h>int SOCKET(int domain , int type , int protocol){int return_value;if((return_value = socket(domain , type , protocol)) == -1){perror("socket call failed!\n");return return_value;}return return_value;
}int BIND(int sockfd , const struct sockaddr* addr , socklen_t addrlen){int return_value;   if((return_value = bind(sockfd , addr , addrlen)) == -1){perror("bind call failed!\n");return return_value;}                      return return_value;   
}int LISTEN(int sockfd , int backlog){int return_value;   if((return_value = listen(sockfd , backlog)) == -1){perror("listen call failed!\n");return return_value;}                      return return_value;   
}ssize_t SEND(int sockfd , const void* buf , size_t len , int flags){ssize_t return_value;if((return_value = send(sockfd , buf , len , flags)) == -1){perror("send call failed!\n");return return_value;}return return_value;
}ssize_t RECV(int sockfd , void* buf , size_t len , int flags){ssize_t return_value;   if((return_value = recv(sockfd , buf , len , flags)) == -1){perror("recv call failed!\n");return return_value;}                      return return_value;   
}int CONNECT(int sockfd , const struct sockaddr* addr , socklen_t addrlen){int return_value;   if((return_value = connect(sockfd , addr , addrlen)) == -1){perror("connect call failed!\n");return return_value;}                      return return_value;   
}int ACCEPT(int sockfd , struct sockaddr* addr , socklen_t addrlen){int return_value;   if((return_value = accept(sockfd , addr , &addrlen)) == -1){perror("accept call failed!\n");return return_value;}                      return return_value;   
}int SOCKET_NET_CREATE(const char* ip , int port){int sockfd;struct sockaddr_in addr;addr.sin_family = AF_INET;addr.sin_port = htons(port);inet_pton(AF_INET , ip , &addr.sin_addr.s_addr);sockfd = SOCKET(AF_INET , SOCK_STREAM , 0);BIND(sockfd , (struct sockaddr*)&addr , sizeof(addr));LISTEN(sockfd , 128);return sockfd;
}int SERVER_ACCEPTING(int server_fd)
{int client_sockfd;struct sockaddr_in client_addr;char client_ip[16];char buffer[1500];bzero(buffer , sizeof(buffer));bzero(&client_addr , sizeof(client_addr));socklen_t addrlen = sizeof(client_addr);client_sockfd = ACCEPT(server_fd , (struct sockaddr*)&client_addr , addrlen);bzero(client_ip , 16);//将客户端的IP地址转成CPU可以识别的序列并存储到client_ip数组中inet_ntop(AF_INET , &client_addr.sin_addr.s_addr , client_ip , 16);sprintf(buffer , "Hi , %s welcome tcp test server service..\n" , client_ip);printf("client %s , %d , connection success , client sockfd is %d\n" , client_ip , ntohs(client_addr.sin_port) , client_sockfd);SEND(client_sockfd , buffer , strlen(buffer) , MSG_NOSIGNAL);return client_sockfd;
}

/*************************************************************************> File Name: epoll_server.c> Author: Nan> Mail: **@qq.com> Created Time: 2023年10月25日 星期三 18时53分30秒************************************************************************/#include <func_2th_parcel.h>#define MAX_EPOLL 100000int main(void)
{int server_sockfd;//服务器套接字文件描述符int epfd;//监听树文件描述符struct epoll_event ready_array[MAX_EPOLL];//由于存放epoll返回的就绪结构体struct epoll_event node;//向监听树中放入的节点int ready_num;//处于就绪状态的套接字的数量int client_sockfd;//客户端套接字文件描述符char rw_buffer[1500];//读写缓冲区int flag;int recv_len = 0;//接受到的数据的长度int i;bzero(rw_buffer , sizeof(rw_buffer));//清空读写缓冲区server_sockfd = SOCKET_NET_CREATE("192.168.79.128" , 6060);//进行网络初始化//初始化epoll结构体node.data.fd = server_sockfd;node.events = EPOLLIN;//监听读事件//初始化监听树，并做错误处理if((epfd = epoll_create(MAX_EPOLL)) == -1){perror("epoll_create call failed\n");exit(-1);}//向监听树中添加服务器套接字结构体，并做错误处理if((epoll_ctl(epfd , EPOLL_CTL_ADD , server_sockfd , &node)) == -1){perror("epoll_ctl call failed\n");exit(-1);}printf("epoll_server wait TCP connect\n");while(1){//获取处于就绪状态的套接字数量if((ready_num = epoll_wait(epfd , ready_array , MAX_EPOLL , -1)) == -1){perror("epoll_wait call failed\n");exit(0);}i = 0;while(ready_num){//辨别就绪，如果是服务端套接字就绪if(ready_array[i].data.fd == server_sockfd){client_sockfd = SERVER_ACCEPTING(ready_array[i].data.fd);//与客户端建立TCP链接node.data.fd = client_sockfd;if(epoll_ctl(epfd , EPOLL_CTL_ADD , client_sockfd , &node) == -1){perror("epoll_ctl failed\n");exit(-1);}}//如果是客户端套接字就绪else{  recv_len = RECV(ready_array[i].data.fd , rw_buffer , sizeof(rw_buffer) , 0);flag = 0;//如果recv_len = 0,就说明与客户端套接字对应的客户端退出了，将对应客户端套接字移出套接字存储数组与监听集合if(recv_len == 0){perror("某一客户端与本服务器断开链接\n");printf("客户端%d 与本服务器断开链接，关闭其对应的套接字并停止监听\n" , ready_array[i].data.fd);//关闭该套接字close(ready_array[i].data.fd);//将其对应的节点从监听树上摘下来epoll_ctl(epfd , EPOLL_CTL_DEL , ready_array[i].data.fd , NULL);//注意，这个两个步骤不能搞反}//进行业务处理：小写字母转大写字母printf("服务器已接收到客户端%d 发来的信息 : %s，现在对其进行处理\n" , ready_array[i].data.fd , rw_buffer);while(recv_len > flag){rw_buffer[flag] = toupper(rw_buffer[flag]);flag++;}printf("服务器已对客户端%d 发来的信息完成处理，处理后的数据为 : %s\n" , ready_array[i].data.fd , rw_buffer);SEND(ready_array[i].data.fd , rw_buffer , recv_len , MSG_NOSIGNAL);bzero(rw_buffer , sizeof(rw_buffer));recv_len = 0;}ready_num--;i++;}}close(server_sockfd);printf("server shutdown\n");return 0;
}

/*************************************************************************> File Name: client.c> Author: Nan> Mail: **@qq.com> Created Time: 2023年10月19日 星期四 18时29分12秒************************************************************************/#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <signal.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <time.h>//服务器实现大小写转换业务int main()
{//1.定义网络信息结构体与读写缓冲区并初始化struct sockaddr_in dest_addr;char buffer[1500];bzero(&dest_addr , sizeof(dest_addr));bzero(buffer , sizeof(buffer));dest_addr.sin_family = AF_INET;dest_addr.sin_port = htons(6060);//字符串ip转大端序列inet_pton(AF_INET , "192.168.79.128" , &dest_addr.sin_addr.s_addr);int sockfd = socket(AF_INET , SOCK_STREAM , 0);int i;//2.判断连接是否成功if((connect(sockfd , (struct sockaddr*) &dest_addr , sizeof(dest_addr))) == -1){perror("connect failed!\n");exit(0);}recv(sockfd , buffer , sizeof(buffer) , 0);printf("%s" , buffer);bzero(buffer , sizeof(buffer));//3.循环读取终端输入的数据while( (fgets(buffer , sizeof(buffer) , stdin) ) != NULL){i = strlen(buffer);buffer[i-1] = '\0';//向服务端发送消息send(sockfd , buffer , strlen(buffer) , MSG_NOSIGNAL);//接收服务端发来的消息recv(sockfd , buffer , sizeof(buffer) , 0);//打印服务端发来的信息printf("response : %s\n" , buffer);//清空读写缓冲区，以便下一次放入数据bzero(buffer , sizeof(buffer));}//4.关闭套接字，断开连接close(sockfd);return 0;
}

结果图示

EPOLL的两种监听模式

1.EPOLLLT，水平触发模式，也被称之为负责模式，如果不进行特殊设置，默认情况下对套接字都是以此模式监听。

在此模式下，当epoll监听到某一套接字就绪时，就会先发送处理通知给上层。之后每隔一段时间就来查看该套接字缓冲区中的数据有没有被处理完。

如果没有处理完，就会继续发送处理通知给上层，一天不处理完就发一天，一周处理不完就发一周，直到缓冲区中的数据被全部处理完毕。这就是所说的负责模式

PS：在此模式下，如果缓冲区中的数据没有被处理完，epoll_wait()无法开启下一轮监听。意思就是如果数据没处理完，就去调用epoll_wait()函数的话，会立即返回，返回值为未处理的就绪事件数量

优点：能够保证套接字缓冲区中的所有数据被处理完毕

缺点：开销比较大

适用场景：该模式适合处理有效期较短、或需要被紧急处理的数据

2.EPOLLET，边缘触发模式，也被称之为不负责模式，使用该模式需要进行手动设置

在此模式下，当epoll监听到某一套接字就绪时，指挥发送一次处理通知给上层。之后无论该套接字缓冲区中的数据有没有被处理完，都与epoll无关，epoll可以立即进入新一轮的监听

优点：开销比较小

缺点：存在隐患，不能够保证套接字缓冲区中的所有数据被处理(完毕)，用户要自行保证数据读取完毕

PS：边缘触发模式一般结合非阻塞读取套接字缓冲区的数据

想要设置边缘触发模式也很简单，按照下面的步骤来就可以了

int sockfd;//套接字文件描述符struct epoll_event node;
node.data.fd = sockfd;
node.events = EPOLLIN|EPOLLET;//监听读事件，监听模式切换为边缘触发模式

以上就是本篇博客的全部内容了，大家有什么地方没有看懂的话，可以在评论区留言给我，咱要力所能及的话就帮大家解答解答

今天的学习记录到此结束啦，咱们下篇文章见，ByeBye！

函数	功能	返回值
int epoll_create(epoll_max);	建立监听红黑树	1.成功，返回值为epoll监听树对应的文件描述符 2.出错，返回 -1，并设置错误码
int epoll_ctl(epfd , option , sockfd , node);	添加/删除节点或修改监听事件	1.成功，返回0 2.出错，返回 -1，并设置错误码
int epoll_wait(epfd , ready_array , ready_max , timeout);	监听套接字相关事件	1.成功，返回值为就绪的套接字数目 2.如果在请求的超时毫秒内没有套接字准备就绪，返回0 3.出错，返回 -1，并设置错误码