poll
poll和select类似，它将用户传入的数组拷贝到内核空间，然后查询每个fd对应的设备状态，如果设备就绪则在设备等待队列中加入一项并继续遍历，如果遍历完所有fd后没有发现就绪设备，则挂起当前进程，直到设备就绪或者主动超时，被唤醒后它又要再次遍历fd。
主要函数和结构：
int poll(struct polled *fds, nfd_t, nfds, int timeout)
参一：指向一个结构体数组的第0个元素的指针，每个数组元素都是一个struct pollfd结构，用于指定测试某个给定的fd的条件
参二：表示fds结构体数组的长度
参三：表示poll函数的超时时间，单位是毫秒
监视并等待多个文件描述符的属性变化.
返回值:
小于0，表示出错
等于0，表示poll函数等待超时
大于0，表示poll由于监听的文件描述符就绪返回，返回就绪的文件描述符的个数。
struct polled{
int fd; //被监视的文件描述符
short events; //需要监测fd的事件（输入、输出、错误）
short revents; //文件描述符的操作结果事件
};events&revents的宏定义：
POLLIN 数据可读
POLLOUT 数据可写
POLLRDNORM 普通数据可读
POLLRDBAND 优先级带数据可读（linux不支持）
POLLPRI 高优先级数据可读，比如TCP带外数据
POLLWRNORM 普通数据可写
POLLWRBAND 优先级带数据可写
POLLRDHUP TCP连接被对端关闭，或者关闭了写操作，由GNU引入
POPPHUP 挂起
POLLERR 错误
POLLNVAL 文件描述符没有打开
举个例子：
#include <iostream>
#include <poll.h>
#include <arpa/inet.h>
#include <unistd.h>
#define MAXLINE 80
#define PORT 8889
#define OPEN_MAX 1024
int main()
{
int iRet;
//最大连接数
pollfd client[OPEN_MAX];
int listenfd = socket(AF_INET, SOCK_STREAM, 0);
std::cout<<"listenfd:"<<listenfd<<std::endl;
sockaddr_in saddr, caddr;
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = htonl(INADDR_ANY);
saddr.sin_port = htons(PORT);
iRet = bind(listenfd,(sockaddr*)&saddr,sizeof(sockaddr));
if(iRet < 0)
std::cout<<"bind fail"<<std::endl;
std::cout<<"bind "<<iRet<<std::endl;
iRet = listen(listenfd,5);
if(iRet < 0)
std::cout<<"listen fail"<<std::endl;
//将监听socket放入到client[0]中
client[0].fd = listenfd;
client[0].events = POLLIN;
//从1开始，如果从0开始会覆盖掉监听描述符，造成永久阻塞
for(int i = 1; i < OPEN_MAX; i++)
{
client[i].fd = -1;
}
int maxi = 0;
std::cout<<"init success"<<std::endl;
while(1)
{
iRet = poll(client, maxi + 1, -1);
if(client[0].revents & POLLIN)
{
int addrlen = sizeof(sockaddr_in);
int connfd = accept(listenfd,(sockaddr*)&caddr,(socklen_t*)&addrlen);
std::cout<<"client connect:"<<"connfd"<<std::endl;
int i;
for(i = 1; i < OPEN_MAX; i++)
{
if(client[i].fd < 0)
{
client[i].fd = connfd;
break;
}
}
if(i == OPEN_MAX)
{
std::cout<<"too many clients"<<std::endl;
}
client[i].events = POLLIN;
if(i > maxi)
maxi = i;
}
else
{
for(int i = 1; i <= maxi; i++)
{
if(client[i].fd < 0)
continue;
if(client[i].revents == POLLIN)
{
char buf[256];
iRet = recv(client[i].fd,buf,sizeof(buf),0);
if(iRet < 0)
{
std::cout<<"error"<<std::endl;
close(client[i].fd);
client[i].fd = -1;
}
else if(iRet == 0)
{
std::cout<<"close connect,sockfd:"<<client[i].fd;
close(client[i].fd);
client[i].fd = -1;
}
else if(iRet > 0)
{
std::cout<<buf<<std::endl;
}
}
}
}
}
return 0;
}
epoll
相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。
在介绍epoll之前，先说说select的缺点：
- 单个进程能够监视的文件描述符的数量存在最大限制，通常是1024，
- 由于select采用轮询的方式扫描文件描述符，文件描述符数量越多，性能越差；
- select返回的是含有整个句柄的数组，还需要遍历整个数组；
- 内核 / 用户空间内存拷贝问题，select需要复制大量的句柄数据结构，产生巨大的开销；
epoll使用了mmap很好的避免了select的第四个缺点。
mmap：
mmap操作提供了一种机制，让用户程序直接访问设备内存，可以理解为开辟了一段内存空间，将用户空间和内核空间需要共享的数据时映射到内存空间中，使用户空间和内核空间都可以访问这一段数据，这种机制，相比较在用户空间和内核空间互相拷贝数据，效率更高。
而在查找上，epoll则使用了一种高性能的数据结构，红黑树。
epoll的接口一共就三个函数：
函数一：
int epoll_create(int size);创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。
需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。
创建epoll模型, 返回值指向红黑树根节点。
函数二：
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
参一：
epoll_create()的返回值
参二：
用三个宏来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；
当添加或者删除一个套接字时，都在红黑树上去处理，时间复杂度O(logN)。
参三：
struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
typedef union epoll_data {
void *ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;
返回0标识成功，返回-1表示失败。events宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，默认为水平触发(Level Triggered)。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里函数三：
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待事件的产生，类似于select()调用。
参一：
epoll_create的返回值。
参二：
events用来从内核得到事件的集合（指针代表这是一个数组）。
参三：
maxevents告之内核这个events有多大，maxevents的值不能大于创建epoll_create()时的size，
参四
timeout是超时时间（毫秒），0会立即返回，-1将不确定，也有说法说是永久阻塞。
该函数返回需要处理的事件数目，如返回0表示已超时。到这里，主要讲述了epoll的基本使用方法，这时，再回到函数一：
int epoll_create(int size);
当某一进程调用epoll_create方法时，Linux内核会创建一个eventpoll结构体
struct eventpoll
{
spin_lock_t lock; //对本数据结构的访问
struct mutex mtx; //防止使用时被删除
wait_queue_head_t wq; //sys_epoll_wait() 使用的等待队列
wait_queue_head_t poll_wait; //file->poll()使用的等待队列
struct list_head rdllist; //事件满足条件的链表
struct rb_root rbr; //用于管理所有fd的红黑树
struct epitem *ovflist; //将事件到达的fd进行链接起来发送至用户空间
}
其中，最关键的是：
struct list_head rdllist; //事件满足条件的链表
struct rb_root rbr; //用于管理所有fd的红黑树
每一个epoll对象都有一个独立的eventpoll结构体，用于存放通过epoll_ctl方法向epoll对象中添加进来的事件，这些事件都会挂载在红黑树中。
所有添加到epoll中的事件都会与设备(网卡)驱动程序建立回调关系，也就是说，当相应的事件发生时会调用这个回调方法。这个回调方法在内核中叫ep_poll_callback,它会将发生的事件添加到rdlist双链表中。
一旦有事件发生，epoll就会将该事件添加到双向链表中。那么当我们调用epoll_wait时，epoll_wait只需要检查rdlist双向链表中是否有存在注册的事件，效率非常可观。这里也需要将发生了的事件复制到用户态内存中即可。
在epoll中，每一个事件都有一个结构体：
struct epitem{
struct rb_node rbn; //红黑树节点
struct list_head rdllink;//双向链表节点
struct epoll_filefd ffd; //事件句柄信息
struct eventpoll *ep; //指向其所属的eventpoll对象
struct epoll_event event; //期待发生的事件类型
}过程：
- epoll_wait调用ep_poll，当rdlist为空（无就绪fd）时挂起当前进程，直到rdlist不空时进程才被唤醒。
- 文件fd状态改变（buffer由不可读变为可读或由不可写变为可写），导致相应fd上的回调函数ep_poll_callback()被调用。
- ep_poll_callback将相应fd对应epitem加入rdlist，导致rdlist不空，进程被唤醒，epoll_wait得以继续执行。
- ep_events_transfer函数将rdlist中的epitem拷贝到txlist中，并将rdlist清空。
- ep_send_events函数（很关键），它扫描txlist中的每个epitem，调用其关联fd对用的poll方法。此时对poll的调用仅仅是取得fd上较新的events（防止之前events被更新），之后将取得的events和相应的fd发送到用户空间（封装在struct epoll_event，从epoll_wait返回）。
最后还有关于ET、LT两种工作模式：
ET模式仅当状态发生变化的时候才获得通知，这里所谓的状态的变化并不包括缓冲区中还有未处理的数据。
如果一次没有读完数据，就需要下次再发生事件后，才能再读剩余数据，容易造成残留数据过多导致程序崩溃。
LT模式是只要有数据没有处理就会一直通知下去的。
贴个代码：
int main()
{
int iRet;
struct epoll_event tep, ep[OPEN_MAX];
int listenfd = socket(AF_INET, SOCK_STREAM, 0);
std::cout<<"listenfd:"<<listenfd<<std::endl;
sockaddr_in saddr, caddr;
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = htonl(INADDR_ANY);
saddr.sin_port = htons(PORT);
iRet = bind(listenfd,(sockaddr*)&saddr,sizeof(sockaddr));
if(iRet < 0)
std::cout<<"bind fail"<<std::endl;
std::cout<<"bind "<<iRet<<std::endl;
iRet = listen(listenfd,5);
if(iRet < 0)
std::cout<<"listen fail"<<std::endl;
int efd = epoll_create(OPEN_MAX); //创建epoll模型, efd指向红黑树根节点
if (efd == -1)
std::cout<<"epoll_create fail"<<std::endl;
tep.events = EPOLLIN;
tep.data.fd = listenfd; //指定lfd的监听时间为"读"
iRet = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep); //将lfd及对应的结构体设置到树上,efd可找到该树
if (iRet == -1)
std::cout<<"epoll_ctl fail"<<std::endl;
while(1)
{
iRet = epoll_wait(efd, ep, OPEN_MAX, -1);
if (iRet == -1)
std::cout<<"epoll_wait fail"<<std::endl;
for (int i = 0; i < iRet; i++)
{
if (!(ep[i].events & EPOLLIN)) //如果不是"读"事件, 继续循环
continue;
if (ep[i].data.fd == listenfd) //判断满足事件的fd是不是lfd
{
int addrlen = sizeof(sockaddr_in);
int connfd = accept(listenfd,(sockaddr*)&caddr,(socklen_t*)&addrlen);
std::cout<<"client connect:"<<connfd<<std::endl;
tep.events = EPOLLIN; tep.data.fd = connfd;
iRet = epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &tep);
if (iRet == -1)
std::cout<<"epoll_ctl fail"<<std::endl;
}
else
{ //不是lfd,
char buf[256];
int n = recv(ep[i].data.fd,buf,sizeof(buf),0);
if (n == 0) { //读到0,说明客户端关闭链接
iRet = epoll_ctl(efd, EPOLL_CTL_DEL, ep[i].data.fd, NULL); //将该文件描述符从红黑树摘除
if (iRet == -1)
std::cout<<"epoll_ctl fail"<<std::endl;
close(ep[i].data.fd); //关闭与该客户端的链接
std::cout<<"close connect,sockfd:"<<ep[i].data.fd<<std::endl;
}
else if (n < 0)
{ //出错
std::cout<<"error"<<std::endl;
iRet = epoll_ctl(efd, EPOLL_CTL_DEL, ep[i].data.fd, NULL);
close(ep[i].data.fd);
} else { //实际读到了字节数
std::cout<<buf<<std::endl;
}
}
}
}
close(listenfd);
close(efd);
return 0;
}
参考资料：
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
