linux poll和epoll

最新推荐文章于 2024-09-27 19:36:56 发布

逐梦如风

最新推荐文章于 2024-09-27 19:36:56 发布

阅读量685

点赞数

分类专栏： linux c/c++ 文章标签：函数内核 linux poll epol

本文链接：https://blog.csdn.net/cabing2005/article/details/53582713

版权

c/c++ 同时被 2 个专栏收录

65 篇文章 0 订阅

订阅专栏

linux

18 篇文章 0 订阅

订阅专栏

linux poll和epoll简介

函数简介

poll的机制与select类似，与select在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是poll没有最大文件描述符数量的限制。poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。

poll函数

　　函数格式如下所示：

# include <poll.h>
int poll ( struct pollfd * fds, unsigned int nfds, int timeout);
pollfd结构体定义如下：
    struct pollfd {
        int fd;         /* 文件描述符 */
        short events;         /* 等待的事件 */
        short revents;       /* 实际发生了的事件 */
    }; 

    每一个pollfd结构体指定了一个被监视的文件描述符，可以传递多个结构体，
    指示poll()监视多个文件描述符。每个结构体的events域是监视该文件描述符的事件掩码，
    由用户来设置这个域。revents域是文件描述符的操作结果事件掩码，
    内核在调用返回时设置这个域。events域中请求的任何事件都可能在revents域中返回。

    合法的事件如下：

    　　POLLIN 　　　　　　　　有数据可读。

    　　POLLRDNORM 　　　　  有普通数据可读。

    　　POLLRDBAND　　　　　 有优先数据可读。

    　　POLLPRI　　　　　　　　 有紧迫数据可读。

    　　POLLOUT　　　　　　      写数据不会导致阻塞。

    　　POLLWRNORM　　　　　  写普通数据不会导致阻塞。

    　　POLLWRBAND　　　　　   写优先数据不会导致阻塞。

    　　POLLMSGSIGPOLL 　　　　消息可用。
    　　此外，revents域中还可能返回下列事件：
    　　POLLER　　   指定的文件描述符发生错误。

    　　POLLHUP　　 指定的文件描述符挂起事件。

    　　POLLNVAL　　指定的文件描述符非法。

这些事件在events域中无意义，因为它们在合适的时候总是会从revents中返回。

使用poll()和select()不一样，你不需要显式地请求异常情况报告。

POLLIN | POLLPRI等价于select()的读事件，
POLLOUT |POLLWRBAND等价于select()的写事件。

POLLIN等价于POLLRDNORM |POLLRDBAND，
而POLLOUT则等价于POLLWRNORM。

例如，要同时监视一个文件描述符是否可读和可写，我们可以设置 events为POLLIN |POLLOUT。

在poll返回时，我们可以检查revents中的标志，对应于文件描述符请求的events结构体。

如果POLLIN事件被设置，则文件描述符可以被读取而不阻塞。
如果POLLOUT被设置，则文件描述符可以写入而不导致阻塞。

这些标志并不是互斥的：它们可能被同时设置，表示这个文件描述符的读取和写入操作都会正常返回而不阻塞。

timeout参数指定等待的毫秒数，无论I/O是否准备好，poll都会返回。timeout指定为负数值表示无限超时，使poll()一直挂起直到一个指定事件发生；
timeout为0指示poll调用立即返回并列出准备好I/O的文件描述符，但并不等待其它的事件。这种情况下，  poll()就像它的名字那样，一旦选举出来，立即返回。


返回值和错误代码
　　成功时，poll()返回结构体中revents域不为0的文件描述符个数；
　　  如果在超时前没有任何事件发生，poll()返回0；失败时，poll()返回-1，并设置errno为下列值之一：
        　　EBADF　　       一个或多个结构体中指定的文件描述符无效。

        　　EFAULTfds　　 指针指向的地址超出进程的地址空间。

        　　EINTR　　　　  请求的事件之前产生一个信号，调用可以重新发起。

        　　EINVALnfds　　参数超出PLIMIT_NOFILE值。

        　　ENOMEM　　     可用内存不足，无法完成请求。

epoll的说明

IO多路复用之epoll总结
1、基本知识

epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

2、epoll接口

　　epoll操作过程需要三个接口，分别如下：

#include <sys/epoll.h>
int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);


（1） int epoll_create(int size);
　　创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

（2）int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

　　epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；
第三个参数是需要监听的fd，第四个参数是告诉内核需要监听什么事，struct epoll_event结构如下：

struct epoll_event {
  __uint32_t events;  /* Epoll events */
  epoll_data_t data;  /* User data variable */
};
events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

（3） int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

等待事件的产生，类似于select()调用。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。

3、工作模式 

epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：

LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。

ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。

ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

统一的client

#include <iostream>

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

#define BUF_LEN 1023

void tserver(int argc, const char * argv[]);

int main(int argc, const char * argv[]) {
    tserver(argc,argv);
    return 0;
}
void tserver(int argc, const char * argv[]){
    std::cout << "t server" << std::endl;
    if(argc < 3){
        exit(-1);
    }

    const char* ip = argv[1];
    int port = atoi(argv[2]);
    int backlog = atoi(argv[3]);

    std::cout << "ip=" << ip << " port="<<port << " backlog=" << backlog  << std::endl;

    int fd;
    int check_ret;

    fd = socket(PF_INET,SOCK_STREAM , 0);
    assert(fd >= 0);

    struct sockaddr_in address;
    bzero(&address,sizeof(address));

    //转换成网络地址
    address.sin_port = htons(port);
    address.sin_family = AF_INET;
    //地址转换
    inet_pton(AF_INET, ip, &address.sin_addr);
    check_ret = connect(fd, (struct sockaddr*) &address, sizeof(address));
    assert(check_ret >= 0);
    //发送数据
    //const char* oob_data = "abc";
    const char* normal_data = "my boy c++11 is a good language!";
    send(fd, normal_data, strlen(normal_data), 0);
    printf("send data len=%lu,msg=%s\n",strlen(normal_data),normal_data);


    //接受数据

    int len;
    char sockBuf[BUF_LEN];
    memset(sockBuf, '\0', BUF_LEN);
    len = recv(fd, sockBuf, BUF_LEN-1, 0);
    printf("receive data len=%d,msg=%s\n",len,sockBuf);

    close(fd);
}

poll使用的例子

server

#include <iostream>
//./server 127.0.0.1 12345 5

#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/time.h>
#include <sys/select.h>
#include <poll.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>

//using namespace std;

#define BUFFER_SIZE 1024
#define HEAD_LEN 4
#define MAX_FD 1023
#define BUF_LEN 1000


void tsocket(int argc, const char * argv[]);

int main(int argc, const char * argv[]) {
    tsocket(argc,argv);
    return 0;
}
void tsocket(int argc, const char * argv[]){
    if(argc < 3){
        exit(-1);
    }

    const char* ip = argv[1];
    int port = atoi(argv[2]);
    int backlog = atoi(argv[3]);

    std::cout << "ip=" << ip << " port="<<port << " backlog=" << backlog  << std::endl;

    //声明信息
    char sockBuf[BUFFER_SIZE];
    int socketfd[MAX_FD];
    char data[BUFFER_SIZE+HEAD_LEN];

    //use pool
    int i,connfd,sockfd;
    int maxi;
    struct pollfd mypool[MAX_FD];

    //接受数据
    size_t ret;

    int fd;
    int check_ret;
    fd = socket(PF_INET,SOCK_STREAM , 0);
    assert(fd >= 0);

    //端口重用
    int   opt   =   1;   
    int   optLen   =   sizeof(opt);  
    setsockopt(fd, SOL_SOCKET,   SO_REUSEADDR,   &opt,   optLen);

    struct sockaddr_in address;
    bzero(&address,sizeof(address));
    //转换成网络地址
    address.sin_port = htons(port);
    address.sin_family = AF_INET;
    //地址转换
    inet_pton(AF_INET, ip, &address.sin_addr);
    //绑定ip和端口
    check_ret = bind(fd,(struct sockaddr*)&address,sizeof(address));
    assert(check_ret >= 0);

    //非阻塞的socket
    int cflags = fcntl(fd,F_GETFL,0);
    fcntl(fd,F_SETFL, cflags|O_NONBLOCK);

    //创建监听队列，用来存放待处理的客户连接
    check_ret = listen(fd, backlog);
    assert(check_ret >= 0);
    struct sockaddr_in addressClient;
    socklen_t clientLen = sizeof(addressClient);

    //监听事件
    mypool[0].fd = fd;
    mypool[0].events = POLLIN ;

    for(i=1;i<MAX_FD;++i){
        mypool[i].fd = -1;
    }

    //运行监听
    maxi = 0;
    int len,nreaday;

    while(1){
        nreaday = poll (mypool, maxi+1, -1);
        if(nreaday <0){
            perror("poll accept error.\n");
            exit(1);
        }
        if(mypool[0].revents & POLLIN){
            connfd = accept(fd,NULL,NULL);
            if(connfd < 0){
                perror("accept error.\n");
                exit(1);
            }
            //监控到可读的connfd，把connfd放入数组
            for(i=1;i<MAX_FD;++i){
                if(mypool[i].fd < 0) {
                    mypool[i].fd  = connfd;
                    printf("read client %d connected\n", connfd);
                    break;
                }
            }
            if(i == MAX_FD){
                perror("too many connection.\n");
                exit(1);
            }
            mypool[i].events = POLLIN;
            if(i > maxi) maxi = i;

            if (--nreaday <= 0) continue;
        }
        for(i=1; i<=maxi ; ++i)
        {
            if((sockfd = mypool[i].fd) < 0)
                continue;
            /*该链接描述符实际发生的事件*/
            if(mypool[i].revents & POLLIN)
            {
                bzero(sockBuf,'\0');
                len = read(sockfd,sockBuf,BUF_LEN);
                //如果没有数据就等待
                if(len <= 0){
                    close(sockfd);              
                    mypool[i].fd = -1;
                    continue;
                }
                printf("client %d receive %s lenght is %d\n", sockfd, sockBuf,len);
                write(sockfd,sockBuf,len);
            }
        }
    }
    close(fd);
}

epool使用的例子

#include <iostream>
//./server 127.0.0.1 12345 5


#include <sys/epoll.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/time.h>
#include <sys/select.h>
#include <poll.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>

//using namespace std;

#define BUFFER_SIZE 1024
#define HEAD_LEN 4
#define MAX_FD 1023
#define EPOOL_FD 1024
#define BUF_LEN 1000



int setnonblocking( int fd )
{
    int old_option = fcntl( fd, F_GETFL );
    int new_option = old_option | O_NONBLOCK;
    fcntl( fd, F_SETFL, new_option );
    return old_option;
}

void addfd( int epollfd, int fd )
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN;
    epoll_ctl( epollfd, EPOLL_CTL_ADD, fd, &event );
    setnonblocking( fd );
}

void deletefd(int epollfd,int fd,int state)
{
    epoll_event ev;
    ev.events = state;
    ev.data.fd = fd;
    epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,&ev);
}

void tsocket(int argc, const char * argv[]);

int main(int argc, const char * argv[]) {
    tsocket(argc,argv);
    return 0;
}
void tsocket(int argc, const char * argv[]){
    if(argc < 3){
        exit(-1);
    }

    const char* ip = argv[1];
    int port = atoi(argv[2]);
    int backlog = atoi(argv[3]);

    std::cout << "ip=" << ip << " port="<<port << " backlog=" << backlog  << std::endl;

    //声明信息
    char sockBuf[BUFFER_SIZE];

    //接受数据
    size_t ret;

    int fd;
    int check_ret;
    fd = socket(PF_INET,SOCK_STREAM , 0);
    assert(fd >= 0);

    //端口重用
    int   opt   =   1;   
    int   optLen   =   sizeof(opt);  
    setsockopt(fd, SOL_SOCKET,   SO_REUSEADDR,   &opt,   optLen);

    struct sockaddr_in address;
    bzero(&address,sizeof(address));
    //转换成网络地址
    address.sin_port = htons(port);
    address.sin_family = AF_INET;
    //地址转换
    inet_pton(AF_INET, ip, &address.sin_addr);
    //绑定ip和端口
    check_ret = bind(fd,(struct sockaddr*)&address,sizeof(address));
    assert(check_ret >= 0);

    //非阻塞的socket
    int cflags = fcntl(fd,F_GETFL,0);
    fcntl(fd,F_SETFL, cflags|O_NONBLOCK);

    //创建监听队列，用来存放待处理的客户连接
    check_ret = listen(fd, backlog);
    assert(check_ret >= 0);
    struct sockaddr_in addressClient;
    socklen_t clientLen = sizeof(addressClient);

    //使用epoll
    epoll_event epollArr[MAX_FD];

    int epollfd = epoll_create(EPOOL_FD);
    assert(epollfd != -1);
    addfd(epollfd,fd);
    setnonblocking(fd);

    int len;
    int socketfd;
    while(1){
        int number = epoll_wait(epollfd,epollArr, MAX_FD, -1);
        if( number < 0){
            printf("epoll error\n");
            break;
        }
        for(int i=0;i<number;++i){
            socketfd = epollArr[i].data.fd;
            //如果是监听的端口放入监听里面
            if(socketfd == fd){
                int connfd = accept(fd,NULL,NULL);
                addfd( epollfd, connfd );
            }else if(epollArr[i].events & EPOLLIN){
                int sockfd = epollArr[i].data.fd;
                while(1){
                    bzero(sockBuf,'\0');
                    len = read(socketfd,sockBuf,BUF_LEN);
                    if(len < 0){
                        close(socketfd);
                        break;
                    }else if(len == 0){
                        close(socketfd);
                    }else{
                        printf("receve:%s\n", sockBuf);
                        write(socketfd,sockBuf,len);
                        //deletefd(epollfd,fd,EPOLLIN);
                    }
                }
            }else{
                printf("other happen\n");
            }
        }

    }
    close(fd);
}