select epoll poll总结

最新推荐文章于 2022-08-09 17:18:16 发布

「已注销」

最新推荐文章于 2022-08-09 17:18:16 发布

阅读量168

点赞数 2

分类专栏： Linux服务器开发文章标签：网络 epoll

本文链接：https://blog.csdn.net/weixin_43519366/article/details/115916698

版权

Linux服务器开发专栏收录该内容

4 篇文章 1 订阅

订阅专栏

epoll

一、从网卡接收数据说起

下图是一个典型的计算机结构图，计算机由CPU、存储器（内存）、网络接口等部件组成。了解epoll本质的第一步，要从硬件的角度看计算机怎样接收网络数据。

下图展示了网卡接收数据的过程。在①阶段，网卡收到网线传来的数据；经过②阶段的硬件电路的传输；最终将数据写入到内存中的某个地址上（③阶段）。这个过程涉及到DMA传输、IO通路选择等硬件有关的知识，但我们只需知道：网卡会把接收到的数据写入内存。

在这里插入图片描述

通过硬件传输网卡接收的数据存放在内存中去，操作系统可以去读取他们

二、如何知道接收了数据？

了解epoll本质的第二步，要从CPU的角度来看数据接收。要理解这个问题，要先了解一个概念——中断。
计算机程序在执行程序的时候，会有优先级的需求。比如
当计算机收到断电信号时（电容可以保存少许电量，供CPU运行很短的一小段时间），它应立即去保存数据，保存数据的程序具有较高的优先级。
一般而言，由硬件产生的信号需要cpu立马做出回应（不然数据可能就丢失），所以它的优先级很高。cpu理应中断掉正在执行的程序，去做出响应；当cpu完成对硬件的响应后，再重新执行用户程序。中断的过程如下图，和函数调用差不多。只不过函数调用是事先定好位置，而中断的位置由“信号”决定。

在这里插入图片描述

以键盘为例，当用户按下键盘某个按键时，键盘会给cpu的中断引脚发出一个高电平。cpu能够捕获这个信号，然后执行键盘中断程序。下图展示了各种硬件通过中断与cpu交互。

在这里插入图片描述

现在可以回答本节提出的问题了：当网卡把数据写入到内存后，网卡向cpu发出一个中断信号，操作系统便能得知有新数据到来，再通过网卡中断程序去处理数据。

三、进程阻塞为什么不占用cpu资源？

了解epoll本质的第三步，要从操作系统进程调度的角度来看数据接收。阻塞是进程调度的关键一环，指的是进程在等待某事件（如接收到网络数据）发生之前的等待状态，recv、select和epoll都是阻塞方法。了解“进程阻塞为什么不占用cpu资源？”，也就能够了解这一步。

//创建socket   socket- bind-listen-recv
int s = socket(AF_INET, SOCK_STREAM, 0);   
//绑定
bind(s, ...)
//监听
listen(s, ...)
//接受客户端连接
int c = accept(s, ...)
//接收客户端数据
recv(c, ...);
//将数据打印出来
printf(...)

这是一段最基础的网络编程代码，先新建socket对象，依次调用bind、listen、accept，最后调用recv接收数据。recv是个阻塞方法，当程序运行到recv时，它会一直等待，直到接收到数据才往下执行。

那么阻塞的原理是什么？

工作队列

操作系统为了支持多任务，实现进程调度的功能，会把进程分为运行和等待等几种状态，运行状态是进程获得CPU使用权，正在执行代码的状态，等待状态是阻塞状态，，比如上述程序运行到recv时，程序会从运行状态变为等待状态，接收到数据后又变回运行状态。操作系统会分时执行各个运行状态的进程，由于速度很快，看上去就像是同时执行多个任务。

下图中的计算机中运行着A、B、C三个进程，其中进程A执行着上述基础网络程序，一开始，这3个进程都被操作系统的工作队列所引用，处于运行状态，会分时执行。

等待队列

当进程A执行到创建socket的语句时，操作系统会创建一个由文件系统管理的socket对象（如下图）。这个socket对象包含了发送缓冲区、接收缓冲区、等待队列等成员。等待队列是个非常重要的结构，它指向所有需要等待该socket事件的进程。

在这里插入图片描述

当程序执行到recv时，操作系统会将进程A从工作队列移动到该socket的等待队列中（如下图）。由于工作队列只剩下了进程B和C，依据进程调度，cpu会轮流执行这两个进程的程序，不会执行进程A的程序。所以进程A被阻塞，不会往下执行代码，也不会占用cpu资源

ps：操作系统添加等待队列只是添加了对这个“等待中”进程的引用，以便在接收到数据时获取进程对象、将其唤醒，而非直接将进程管理纳入自己之下。上图为了方便说明，直接将进程挂到等待队列之下。

唤醒进程

当socket接收到数据后，操作系统将该socket等待队列上的进程重新放回到工作队列，该进程变成了运行状态，继续执行代码。也由于socket的接收缓冲区已经有了数据，recv可以返回接收到的数据

四、内核接收网络数据全过程

如下图所示，进程在recv阻塞期间，计算机收到了对端传送的数据（步骤①）。数据经由网卡传送到内存（步骤②），然后网卡通过中断信号通知cpu有数据到达，cpu执行中断程序（步骤③）。此处的中断程序主要有两项功能，先将网络数据写入到对应socket的接收缓冲区里面（步骤④），再唤醒进程A（步骤⑤），重新将进程A放入工作队列中。

在这里插入图片描述

唤醒进程的过程如下图所示。

在这里插入图片描述

以上是内核接收数据全过程

其一，操作系统如何知道网络数据对应于哪个socket？

因为一个socket对应一个端口号，而网络数据包中包含了IP和端口的信息，内核可以通过端口号找到对应的socket。当然，为了提高处理速度，操作系统会维护端口号到socket的索引结构，以快速读取。建立套接字连接的时候要绑定端口号

五、同时监视多个socket的简单方法

服务端需要多个客户端连接，而recv只能监视单个socket,这种矛盾下，人们开始寻找监视多个socket的方法。epoll的要义是高效监听多个socket.从历史发展角度看，必然先出现一种不太高效的方法，人们再加以改进。只有先理解了不太高效的方法，才能够理解epoll的本质。
假如能够预先传入一个socket列表，如果列表中的socket都没有数据，挂起进程，直到有一个socket收到数据，唤醒进程。这种方法很直接，也是select的设计思想。
为方便理解，我们先复习select的用法。在如下的代码中，先准备一个数组（下面代码中的fds），让fds存放着所有需要监视的socket。然后调用select，如果fds中的所有socket都没有数据，select会阻塞，直到有一个socket接收到数据，select返回，唤醒进程。用户可以遍历fds，通过FD_ISSET判断具体哪个socket收到数据，然后做出处理。

int s = socket(AF_INET, SOCK_STREAM, 0);  
bind(s, ...)
listen(s, ...)

int fds[] =  存放需要监听的socket

while(1){
    int n = select(..., fds, ...)
    for(int i=0; i < fds.count; i++){
        if(FD_ISSET(fds[i], ...)){
            //fds[i]的数据处理
        }
    }
}

select的流程

select的实现思路很直接。假如程序同时监视如下图的sock1、sock2和sock3三个socket，那么在调用select之后，操作系统把进程A分别加入这三个socket的等待队列中。
select的底层实现是链表

当任何一个socket收到数据后，中断程序将唤起进程。下图展示了sock2接收到了数据的处理流程。

所谓唤起进程，就是将进程从所有的等待队列中移除，加入到工作队列里面。如下图所示。

在这里插入图片描述

经由这些步骤，当进程A被唤醒后，它知道至少有一个socket接收了数据。程序只需遍历一遍socket列表，就可以得到就绪的socket。
这种简单方式行之有效，在几乎所有操作系统都有对应的实现。

缺点

其一，每次调用select都需要将进程加入到所有监视socket的等待队列，每次唤醒都需要从每个队列中移除。这里涉及了两次遍历，而且每次都要将整个fds列表传递给内核，有一定的开销。正是因为遍历操作开销大，出于效率的考量，才会规定select的最大监视数量，默认只能监视1024个socket。
其二，进程被唤醒后，程序并不知道哪些socket收到数据，还需要遍历一次。

6 epoll的设计思路

措施一：功能分离

select低效的原因之一是将“维护等待队列”和“阻塞进程”两个步骤合二为一。如下图所示，每次调用select都需要这两步操作，然而大多数应用场景中，需要监视的socket相对固定，并不需要每次都修改。epoll将这两个操作分开，先用epoll_ctl维护等待队列，再调用epoll_wait阻塞进程。显而易见的，效率就能得到提升

。
在这里插入图片描述

为方便理解后续的内容，我们先复习下epoll的用法。如下的代码中，先用epoll_create创建一个epoll对象epfd，再通过epoll_ctl将需要监视的socket添加到epfd中，最后调用epoll_wait等待数据。
int s = socket(AF_INET, SOCK_STREAM, 0);
bind(s, …)
listen(s, …)
int epfd = epoll_create(…);
epoll_ctl(epfd, …); //将所有需要监听的socket添加到epfd中
while(1){
int n = epoll_wait(…)
for(接收到数据的socket){
//处理
}
}

措施二：就绪列表

select低效的另一个原因在于程序不知道哪些socket收到数据，只能一个个遍历。如果内核维护一个“就绪列表”，引用收到数据的socket，就能避免遍历。如下图所示，计算机共有三个socket，收到数据的sock2和sock3被rdlist（就绪列表）所引用。当进程被唤醒后，只要获取rdlist的内容，就能够知道哪些socket收到数据。

在这里插入图片描述

对于epoll:
大学女生宿舍，你想找你对象，于是你找到舍管大妈，把你女朋友的名字和宿舍房号报给舍管大妈，大妈直接就可以帮你找到你女朋友。
对于select:
还是女生宿舍，你告诉舍管大妈你女朋友的名字，但是舍管大妈，是带着你从一楼101开始一件一件宿舍去找你女朋友…

7 epoll的原理和流程

如下图所示，当某个进程调用epoll_create方法时，内核会创建一个eventpoll对象（也就是程序中epfd所代表的对象）。eventpoll对象也是文件系统中的一员，和socket一样，它也会有等待队列。

在这里插入图片描述

创建一个代表该epoll的eventpoll对象是必须的，因为内核要维护“就绪列表”等数据，“就绪列表”可以作为eventpoll的成员。

维护监视列表

创建epoll对象后，可以用epoll_ctl添加或删除所要监听的socket，以添加socket位列，下图，如果通过epoll_ctl添加sock1、sock2和sock3的监视，内核会将eventpoll添加到这三个socket的等待队列中。

在这里插入图片描述

当socket收到数据后，中断程序会操作eventpoll对象，而不是直接操作进程。

接收数据

当socket收到数据后，中断程序会给eventpoll的“就绪列表”添加socket引用。如下图展示的是sock2和sock3收到数据后，中断程序让rdlist引用这两个socket。
这里是引用

在这里插入图片描述

eventpoll对象相当于是socket和进程之间的中介，socket的数据接收并不直接影响进程，而是通过改变eventpoll的就绪列表来改变进程状态。

当程序执行到epoll_wait时，如果rdlist已经引用了socket，那么epoll_wait直接返回，如果rdlist为空，阻塞进程。

阻塞和唤醒进程

假设计算机中正在运行进程A和进程B，在某时刻进程A运行到了epoll_wait语句。如下图所示，内核会将进程A放入eventpoll的等待队列中，阻塞进程。

当socket接收到数据，中断程序一方面修改rdlist，另一方面唤醒eventpoll等待队列中的进程，进程A再次进入运行状态（如下图）。也因为rdlist的存在，进程A可以知道哪些socket发生了变化。

在这里插入图片描述

八、epoll的实现细节

，相信读者对epoll的本质已经有一定的了解。但我们还留有一个问题，eventpoll的数据结构是什么样子？
再留两个问题，就绪队列应该应使用什么数据结构？eventpoll应使用什么数据结构来管理通过epoll_ctl添加或删除的socket？
如下图所示，eventpoll包含了lock、mtx、wq（等待队列）、rdlist等成员。rdlist和rbr是我们所关心的。

就绪列表的数据结构
就绪列表引用了就绪的socket，所以它能快速的插入数据
程序可能随时调用epoll_ctl添加socket，也可能随时删除
当删除时，若该socket已经存放在就绪列表中，它也应该被移除。
所以就绪列表应是一种能够快速插入和删除的数据结构。双向链表就是这样一种数据结构，epoll使用双向链表来实现就绪队列（对应上图的rdllist）。

索引结构

既然epoll将“维护监视队列”和“进程阻塞”分离，也意味着需要有个数据结构来保存监视的socket。至少要方便的添加和移除，还要便于搜索，以避免重复添加。红黑树是一种自平衡二叉查找树，搜索、插入和删除时间复杂度都是O(log(N))，效率较好。epoll使用了红黑树作为索引结构（对应上图的rbr）。

ps：因为操作系统要兼顾多种功能，以及由更多需要保存的数据，rdlist并非直接引用socket，而是通过epitem间接引用，红黑树的节点也是epitem对象。同样，文件系统也并非直接引用着socket。为方便理解，本文中省略了一些间接结构。

9结论

epoll在select和poll（poll和select基本一样，有少量改进）的基础引入了eventpoll作为中间层，使用了先进的数据结构，是一种高效的多路复用技术。

epoll的使用

1 Epoll和select的区别对比

e1poll不存在集合的覆盖 epoll_create会返回一个fd，指向空间包含全部的事件（结构体）
2epoll把要监听的每一个fd都包装成一个事件，并把这个事件记入epollfd 让epollfd来监听
3select产生动静是吧fd放入集合但是epoll通过epoll_wait 把产生动静的fd所包装好的事件放入结构体数组
4select需要备份，需要重新创建数组放fd循环比对，epoll直接通过包装好的事件（结构体）就能获得fd，效率也更快（差别主要体现在这）
5两者的区别是的select适合用户客服端不多的情况，而epoll没有客户端的上限

Epoll模型的三个函数

** 函数原型+功能说明**

#include <sys/epoll.h>

int epoll_create(int size);
作用：创建一个epoll句柄，告诉他需要监听的数目（也可以理解成申请一片空间，用于存放监听的套接字）

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
作用：控制某个epoll监控的文件描述符上的事件：注册，修改、删除（也就是增添 删除 修改一个事件）

int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout)

2.2 epoll_create()参数使用

int epoll_create(int size); 参数一：通知内核监听size个fd，只是个建议值并与硬件有关系。（从 Linux
内核 2.6.8 版本起，size 这个参数就被忽略了，只要求 size 大于 0 即可）返回值：返回epoll句柄（fd）
2.3 epoll_ctl()参数使用 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
参数一：int epfd:epoll_create()的返回值
参数二：int op：表示动作，用三个宏来表示

EPOLL_CTL_ADD(注册新的fd到epfd) EPOLL_CTL_MOD(修改已经注册的fd监听事件)
EPOLL_CTL_DEL(从epfd删除一个fd)

参数三：int fd 操作对象（socket）
参数四：struct epoll_evevt* evevt; 告诉内核需要监听的事件

结构体如下：

struct epoll_event {
__uint32_t events; 宏定义读和写EPOLLIN读EPOLLOUT写 epoll_data_t data; 联合体 }; 联合体如下：

typedef union epoll_data { void *ptr; int fd;
__uint32_t u32;
__uint64_t u64; } epoll_data_t;

返回值：成功返回0,不成功返回-1
特别注意参数四的使用

2.4 epoll_wait()参数使用

int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout)
参数一：int epfd:epoll_create()函数返回值
参数二：struct epoll_events events用于回传代处理事件的数组（也就是存放产生动静的事件）
参数三:int maxevents 同时最多产生多少事件，告诉内核events有多大，该值必须大于0
参数四:int timeout表示 -1相当于阻塞，0相当于非阻塞，超时时间(单位：毫秒) 返回值：成功返回产生动静事件的个数*

补充说明：产生动静是指
有新的客户端需要连接或者
已连接的客户端发送了信息
3 Epoll模型封装成类
头文件

const int  MAXEPOLLSIZE = 10;

class Epoll
{
   public:
       Epoll();
       bool Add(int fd,int eventsOption);//添加事件

       //Returns the number of triggered events
       int Wait();//等待事件触发
	   bool Del(int fd);
       //bool Delete(const int eventIndex);//删除事件
       int  GetEventOccurfd(const int eventIndex) const;//得到事件数组某个值的fd
       int  GetEvents(const int eventIndex) const;//得到事件数组的宏//可读可写，触发方式

   private:
        int epollfd;//epoll专用文件描述符
        int fdNumber;//epollfd里面客户端有多少
        
        struct epoll_event event;//事件
        struct epoll_event events[MAXEPOLLSIZE];
        struct rlimit  rt;

};

源文件

#include "Epoll.h"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>

Epoll::Epoll():fdNumber(0)
{
    rt.rlim_max= rt.rlim_cur = MAXEPOLLSIZE; 
    if(::setrlimit(RLIMIT_NOFILE,&rt) == -1){
        std::cout << "setlimit failed\n";
        exit(1);
    }

    epollfd = epoll_create(MAXEPOLLSIZE);
    //创建epoll句柄，上限为MAXEPOLLSIZE
}

bool Epoll::Add(int fd,int eventsOption)//把监听到的fd放到epoll句柄里面
{
     event.data.fd = fd;
     event.events = eventsOption; //EPOLLIN | EPOLLET
     if(epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&event) < 0){
         return false;
     }

     fdNumber++;//文件描述符的数量+1
     return true;
}


bool Epoll::Del(int fd)
{
	event.data.fd = fd;
	event.events = EPOLLIN | EPOLLET;
	int ret = epoll_ctl(epollfd, EPOLL_CTL_DEL,fd, &event);
	if (ret<0)
	{
		return false;
     }
	close(event.data.fd);
	printf("client is close ,fd = %d\n", event.data.fd);
	return true;
}
int Epoll::Wait()
{
    int eventNumber;//初始化事件响应数量
    eventNumber = epoll_wait(epollfd,events,fdNumber,-1);
    if(eventNumber < 0){
        std::cout << "epoll_wait  failed \n";
        exit(1);
    }
    return eventNumber;
}


int Epoll::GetEventOccurfd(const int eventIndex) const
{
    return events[eventIndex].data.fd;
}

int Epoll::GetEvents(const int eventIndex) const
{
    return events[eventIndex].events;
}

4 Epoll简单实现打印代码+解释

服务端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#define MAXLINE 80
#define SERV_PORT 8000 //端口号
#define OPEN_MAX 1024  //最多连接数



int main(int argc,char *argv[])
{	
	int maxi,sockfd,connfd;//sockfd 用来监听 connfd用来连接的· 监听套接字要自己创建  连接套接字等待返回就行不需要socket
	int nready,efd; //efd是 epoll模型标识符 nready 产生的动静数
	struct sockaddr_in clientaddr, serveraddr;
	struct epoll_event event, events[OPEN_MAX]; //一个果篮 一个结构体
	
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    bzero(&serveraddr, sizeof(serveraddr));
	bzero(&clientaddr, sizeof(clientaddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons(SERV_PORT);
	int on =1;
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) ;//设置为可重复使用的端口
    bind(sockfd, (struct sockaddr *) &serveraddr, sizeof(serveraddr));
    listen(sockfd, OPEN_MAX);//服务器套接字
	efd=epoll_create(OPEN_MAX);
	/*包装服务器fd为事件*/
	event.events=EPOLLIN|EPOLLET;
	event.data.fd=sockfd;
    epoll_ctl(efd,EPOLL_CTL_ADD,sockfd,&event);//把服务器fd包装成事件放在红黑树上	
    while(1)
	{
		//参数一 epollfd 参数二 产生动静的结构体数组 参数三 同时最多产生多少动静 参数四 超市时间
		nready=epoll_wait(efd,events,OPEN_MAX,-1);//返回值为动静数量
		for(int i=0;i<nready;i++)
		{        	
			if(!(events[i].events & EPOLLIN))//判断为可读事件 不是立刻返回循环 与select不同
				continue;
			if (events[i].data.fd==sockfd)//表示有新的连接
			{
				int len=sizeof(clientaddr);
				char ipstr[128];//打印用到
				connfd=accept(sockfd,(struct sockaddr *)&clientaddr,&len);
				printf("client ip%s ,port %d\n",inet_ntop(AF_INET,&clientaddr.sin_addr.s_addr,ipstr,sizeof(ipstr)),
					ntohs(clientaddr.sin_port));
				event.events = EPOLLIN|EPOLLET; 
				event.data.fd = connfd;  
				epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &event);			
			}
			else//表示旧的数据产生可读事件（1 客户端发来数据 2 客户端断开链接）
			{				
     			connfd=events[i].data.fd;
				char buf [1024];
				memset(buf,0,1024);
				int nread;			nread=read(connfd,buf,sizeof(buf));
				
				if(nread==0)
				{
					printf("client is close..\n"); //打印
					epoll_ctl(efd, EPOLL_CTL_DEL, connfd, NULL);//删除果子 select是从集合 和 数组 删除
					close(connfd);//关闭客服端 select一样
                }
				else
				{
					printf("%s",buf);
				}			
			}		
		}	
	}	
}

客服端

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc,char* argv[])
{
	int sfd;
	struct sockaddr_in sfdaddr; //指定要连接服务器的结构体 ip 端口
	int len;	
	char wbuf[1024];	
	//1.socket  通信用套接字，创建一个socket
	sfd = socket(AF_INET,SOCK_STREAM,0);         	
	char ipstr[] = "127.0.0.1";           //要连上的ip地址
	//初始化地址
	bzero(&sfdaddr,sizeof(sfdaddr));	
	sfdaddr.sin_family = AF_INET;
	sfdaddr.sin_port = htons(8000);	
	int on =1;
	setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) ;//设置为可重复使用的端口
	inet_pton(AF_INET,ipstr,&sfdaddr.sin_addr.s_addr); //转换ip 保存到结构体内 
	
	//2.connect  主动连接服务器
	connect(sfd,(struct sockaddr *)&sfdaddr,sizeof(sfdaddr));
	memset(wbuf,0,1024);
	printf("please input\n"); 
	while(1)
	{			   		  
		fgets(wbuf, 100, stdin);//stdin 意思是键盘输入
		write(sfd,wbuf,sizeof(wbuf));	
		memset(wbuf,0,1024);					 
	}	
	close(sfd);
	return 0;
}

「已注销」

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
select epoll poll总结

epoll一、从网卡接收数据说起下图是一个典型的计算机结构图，计算机由CPU、存储器（内存）、网络接口等部件组成。了解epoll本质的第一步，要从硬件的角度看计算机怎样接收网络数据。下图展示了网卡接收数据的过程。在①阶段，网卡收到网线传来的数据；经过②阶段的硬件电路的传输；最终将数据写入到内存中的某个地址上（③阶段）。这个过程涉及到DMA传输、IO通路选择等硬件有关的知识，但我们只需知道：网卡会把接收到的数据写入内存。通过硬件传输网卡接收的数据存放在内存中去，操作系统可以去读取他们二、
复制链接

扫一扫