222-I/O复用函数的使用(epoll)

爱被打了一巴掌 2022-11-07 14:43 1阅读 0赞

## epoll（epoll是Linux专用的） ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]

无论是select还是poll之前，我们都准备有一个集合，然后传给select或者poll。  
**poll是一个系统调用。select也是系统调用。**  
![在这里插入图片描述][20210312202838392.png_pic_center]  
**poll的实现在内核实现**。我们每一次传递数组，要从目录拷贝到内核空间。  
select也是内核实现，每一次在调用，传递集合，也要从目录拷贝到内核空间。  
**poll和select每一次循环调用，都要向内核空间传递大量的数据，（拷贝数据）**

**我们就算把数据传给select或者poll，他们两个在内核中是轮循方式检查数据。检查10人，10秒，检查100人，100秒。时间复杂度：O(n)。**

而且select或者poll的返回值只是说几个描述符有数据，没有告诉我们是哪几个。  
我们要处理，只知道个数，怎么找？  
循环遍历所有描述符，找到就绪描述符的时间复杂度：O(n)；

**当n趋向于正无穷的时候，这时候内核实现效率下降！！！**  
如果描述符很少，用select或者poll就可以。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 1]

## epoll 的接口介绍（解决客户端有大量的，描述符有大量的） ##

**epoll 是 Linux 特有的 I/O 复用函数**。它在实现和使用上与 select、poll 有很大差异。首先，epoll 使用一组函数来完成任务，而不是单个函数。其次，epoll 把用户关心的文件描述符上的事件放在内核里的一个事件表中。从而无需像 select 和 poll 那样每次调用都要重复传入文件描述符或事件集。但 epoll 需要使用一个额外的文件描述符，来唯一标识内核中的这个事件表。**epoll 相关的函数如下：**

◼ **epoll\_create()** //用于创建内核事件表，后面可以把描述符和事件添加进去，在内核中实现，具体表现是红黑树。目的是我们在添加描述符的时候，只添加一次就可以！以后都不需要添加！！！select和poll是无法保存这些数据，而且他们还要去修改的。  
**内核实现是回调函数，当我们发现这个描述符有数据，我们把他放到队列中，举个例子：我坐在讲台上，注册回调函数，我就说：如果你们谁完成作业了，就交上来。我检测10人，100人是没有区别的。我坐在讲台，拿走多少作业是没有区别的！！！select和poll得循环去检测谁做作业了。而epoll是我坐在讲台上等，等5秒钟就超时，有多少收多少，开销是相同的，时间复杂度是O(1)**

**◼ epoll\_ctl()用于操作内核事件表（是红黑树实现的）**

\*\*◼ epoll\_wait()\*\*用于在一段超时时间内等待一组文件描述符上的事件,获取就绪描述符，返回的n是有n个元素就绪的。但是它会直接把就绪的描述符给你，内核检测把就绪的描述符添加到数组中，我们拿到手的就是就绪描述符，我们是直接拿到就绪描述符，不需要循环遍历去找！！！这里的时间复杂度是O(1)。我们执行i<n就可以，直接处理就绪的描述符。

**其各自的原型如下：**

#include <sys/epoll.h>
    
    int epoll_create(int size);
    /*
    epoll_create()成功返回内核事件表的文件描述符，失败返回-1
    因为底层实现是红黑树，树是不能一开始就可以确定大小的，所以size 参数现在并不起作用，只是给内核一个提示，告诉它事件表需要多大。给个大于0的就可以了。
    不能设置-1,0
    */
    
    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    
    epoll_ctl()成功返回 0，失败返回-1
    epfd 参数指定要操作的内核事件表的文件描述符
    fd 参数指定要操作的文件描述符
    op 参数指定操作类型：
    EPOLL_CTL_ADD 往内核事件表中注册 fd 上的事件
    EPOLL_CTL_MOD 修改 fd 上的注册事件
    EPOLL_CTL_DEL 删除 fd 上的注册事件
    event 参数指定事件，它是 epoll_event 结构指针类型，epoll_event 的定义如下：
    struct epoll_event
    {
        
    _uint32_t events; // epoll 事件
    epoll_data_t data; // 用户数据
    };
    其中，events 成员描述事件类型，epoll 支持的事件类型与 poll 基本相同，表示
    epoll 事件的宏是在 poll 对应的宏前加上‘E’，比如 epoll 的数据可读事件是
    EPOLLIN。但是 epoll 有两个额外的事件类型--EPOLLET 和 EPOLLONESHOT。
    data 成员用于存储用户数据，是一个联合体，其定义如下：
    typedef union epoll_data
    {
        
    void *ptr;
    int fd;
    uint32_t u32;
    uint64_t u64;
    }epoll_data_t;
    其中 fd 成员使用的最多，它指定事件所从属的目标文件描述符。
    
    
    int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
    
    
    epoll_wait()成功返回就绪的文件描述符的个数，失败返回-1，超时返回 0
    epfd 参数指定要操作的内核事件表的文件描述符
    events 参数是一个用户数组，这个数组仅仅在 epoll_wait 返回时保存内核检测到的所有就绪事件，而不像 select 和 poll 的数组参数那样既用于传入用户注册的事件，又用于输出内核检测到的就绪事件。这就极大地提高了应用程序索引就绪文件描述符的效率。
    maxevents 参数指定用户数组的大小，即指定最多监听多少个事件，它必须大于0
    timeout 参数指定超时时间，单位为毫秒，如果 timeout 为 0，则 epoll_wait 会立即
    返回，如果 timeout 为-1，则 epoll_wait 会一直阻塞，直到有事件就绪。

![在这里插入图片描述][20210312211341550.png_pic_center]

## LT 和 ET 模式 ##

epoll 对文件描述符有两种操作模式：LT（Level Trigger，电平触发）模式和 ET（EdgeTrigger，边沿触发）模式。LT 模式是默认的工作模式。当往 epoll 内核事件表中注册一个文件描述符上的 EPOLLET 事件时，epoll 将以高效的 ET 模式来操作该文件描述符。  
对于 LT 模式操作的文件描述符，当 epoll\_wait 检测到其上有事件发生并将此事件通知应用程序后，应用程序可以不立即处理该事件。这样，当应用程序下一次调用 epoll\_wait 时，还会再次向应用程序通告此事件，直到该事件被处理  
对于 ET 模式操作的文件描述符，当 epoll\_wait 检测到其上有事件发生并将此事件通知应用程序后，应用程序必须立即处理该事件，因为后续的epoll\_wait 调用将不再向应用程序通知这一事件。所以 ET 模式在很大程度上降低了同一个 epoll 事件被重复触发的次数，因此效率比 LT 模式高。

## epoll 的示例代码 ##

**使用 epoll 实现的 TCP 服务器代码如下**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]  
**封装函数如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]  
![在这里插入图片描述][20210312205929638.png_pic_center]  
**实现主函数**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]  
**我们这里先移除再close，是因为描述符在内核中，内核要利用文件描述符去寻找它。** fd的值是不变的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]  
**运行服务器端和客户端！**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]

#define _GNU_SOURCE
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <assert.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <netinet/in.h>
    #include <sys/epoll.h>
    #include <fcntl.h>
    #include <errno.h>
    
    #define MAX_FD 128
    #define DATALEN 1024
    #define EPOLLSIZE 5
    #define LT 0
    #define ET 1
    
    // 初始化服务器端的 sockfd 套接字
    int InitSocket()
    {
        
    	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    	if(sockfd == -1) return -1;
    
    	struct sockaddr_in saddr;
    	memset(&saddr, 0, sizeof(saddr));
    	saddr.sin_family = AF_INET;
    	saddr.sin_port = htons(6000);
    	saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    	int res = bind(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));
    	if(res == -1) return -1;
    
    	res = listen(sockfd, 5);
    	if(res == -1) return -1;
    
    	return sockfd;
    }
    
    // 设置文件为非阻塞模式
    void SetNoWait(int fd)
    {
        
    	int old_option = fcntl(fd, F_GETFL);
    	int new_option = old_option | O_NONBLOCK;
    	fcntl(fd, F_SETFL, new_option);
    }
    
    //关闭客户端连接
    void CloseClient(int epfd, int fd)
    {
        
    	close(fd);
    	printf("A Client disconnected\n");
    	if (epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL) == -1)
    	{
        
    		printf("epoll_ctl del error\n");
    	}
    }
    
    //获取一个新的客户端连接，如果 flag 为 ET，则以 ET 模式处理此客户端
    void GetClientLink(int sockfd, int epfd, int flag)
    {
        
    	struct sockaddr_in caddr;
    	socklen_t len = sizeof(caddr);
    	int c = accept(sockfd, (struct sockaddr*)&caddr, &len);
    	if (c < 0)
    	{
        
    		printf("Client Link error\n");
    		return;
    	}
    
    	struct epoll_event ev;
    	ev.data.fd = c;
    	if (flag)
    	{
        
    		ev.events = EPOLLIN | EPOLLRDHUP | EPOLLET;
    		SetNoWait(c);
    	}
    	else
    	{
        
    		ev.events = EPOLLIN | EPOLLRDHUP;
    	}
    
    	if (epoll_ctl(epfd, EPOLL_CTL_ADD, c, &ev) == -1)
    	{
        
    		printf("epoll_ctl add error\n");
    	}
    }
    
    //LT 模式的客户端数据处理方式
    void LTDealClientData(int epfd, int fd)
    {
        
    	char buff[DATALEN] = {
         0 };
    	int n = recv(fd, buff, DATALEN - 1, 0);
    	if (n <= 0)
    	{
        
    		CloseClient(epfd, fd);
    		return;
    	}
    
    	printf("%d: %s\n", fd, buff);
    	send(fd, "OK", 2, 0);
    }
    
    //ET 模式的客户端数据处理方式
    void ETDealClientData(int epfd, int fd)
    {
        
    	while (1)
    	{
        
    		char buff[DATALEN] = {
         0 };
    		int n = recv(fd, buff, DATALEN - 1, 0);
    		if (n == -1)
    		{
        
    			if (errno == EAGAIN || errno == EWOULDBLOCK)
    			{
        
    				printf("read later\n");
    				break;
    			}
    			else
    			{
        
    				CloseClient(epfd, fd);
    				break;
    			}
    		}
    		else if (n == 0)
    		{
        
    			CloseClient(epfd, fd);
    			break;
    		}
    		else
    		{
        
    			printf("%d: %s\n", fd, buff);
    			send(fd, "OK", 2, 0);
    		}
    	}
    }
    
    // 处理就绪的文件描述符上的数据
    void DealReadyEvent(struct epoll_event *events,int n,int sockfd,int epfd)
    {
        
    	int i = 0;
    	for (; i < n; ++i)
    	{
        
    		int fd = events[i].data.fd;
    		if (fd == sockfd)
    		{
        
    			GetClientLink(sockfd, epfd, LT); // 设置为 LT 模式
    			// GetClientLink(sockfd, epfd, ET); // 设置为 ET 模式
    		}
    		else if (events[i].events & EPOLLRDHUP)
    		{
        
    			CloseClient(epfd, fd);
    		}
    		else if (events[i].events & EPOLLIN)
    		{
        
    			LTDealClientData(epfd, fd); // 以 LT 模式处理客户端数据
    			//ETDealClientData(epfd, fd); //以 ET 模式处理客户端数据
    		}
    		else
    		{
        
    			printf("error\n");
    		}
    	}
    }
    
    int main()
    {
        
    	int sockfd = InitSocket();
    	assert(sockfd != -1);
    
    	int epfd = epoll_create(EPOLLSIZE);
    	assert(epfd != -1);
    
    	struct epoll_event ev;
    	ev.data.fd = sockfd;
    	ev.events = EPOLLIN;
    
    	if (epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev) == -1)
    	{
        
    		printf("epoll_ctl add error\n");
    		exit(0);
    	}
    
    	while (1)
    	{
        
    		struct epoll_event events[MAX_FD];
    		int n = epoll_wait(epfd, events, MAX_FD, 2000);
    		if (n < 0)
    		{
        
    			printf("epoll_wait error\n");
    			continue;
    		}
    		else if (n == 0)
    		{
        
    			printf("timeout\n");
    			continue;
    		}
    		else
    		{
        
    			DealReadyEvent(events, n, sockfd, epfd);
    		}
    	}
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221023/69c4fc1de19547f2bf08e8e279c6afc6.png
[20210312202838392.png_pic_center]: /images/20221023/15b2d87ec41941d6aa60a8d4a683b0aa.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20221023/40506262767e4447990f016d3d2378ec.png
[20210312211341550.png_pic_center]: /images/20221023/2f94b0dd8b1f4a6db68d55c669c29d01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221023/48d2e5868ee54cbfa3cfe38e4520fee3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221023/fc250bb37c194963aae82f67c5e7c093.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221023/b77c5f5e7fbe4bfea3b21668abc3ab0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221023/5f84a6bace2146c0a1577215342429ec.png
[20210312205929638.png_pic_center]: /images/20221023/e379137a9be141f196a2cc06315c8379.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221023/21549f54104e49a4a1295e5ae0dc6b15.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221023/0311b6eebfd3490485a4149f11607ee1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221023/7ec3681b95ff423e84815def48d21e52.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221023/8e4f2a323e25405589486f2e52b994a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221023/013eb778f6c444ac9e3be229679a188e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221023/89c87f0724384d6499e44082d9d25e10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221023/84949d0dae75442a86fbd99b8e9fda44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221023/12940f994f5642e4beeb8348286ddd35.png