linux epoll poll select

1.select模型

select所需要的头文件：
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

select函数定义：
int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
struct timeval *timeout);

fd_set操作函数：
FD_CLR(int fd, fd_set *set);    // 用于在文件描述符集合中删除一个文件描述符
FD_ISSET(int fd, fd_set *set);  // 用于检查指定的文件描述符是否在该集合中
FD_SET(int fd, fd_set *set);    // 用于在文件描述符集合中增加一个新的文件描述符。
FD_ZERO(fd_set *set);          // 将指定的文件描述符集清空

timeval的定义如下:
struct timeval {
     long tv_sec; /* seconds */
     long tv_usec; /* 10E-6 second */
};

fd_set   readfds;
FD_ZERO(&readfds);
FD_SET(sock, &readfds);

struct timeval timeout;
timeout.tv_sec  =  2;
timeout.tv_usec =  0;
int ret = select(sock + 1, &readfds, NULL, NULL, &timeout);
// select函数返回以后会修改readfds和timeout内的值
if (ret > 0)
{
     if (FD_ISSET(sock, &readfds))
    {
         // 可读
    }
}

 select模式的特点：
1.单个进程监测的fd受限制，默认下是1024个文件描述符；
2.轮询式检查文件描述符集合中的每个fd可读可写状态，IO效率会随着描述符集合增大而降低；
3.可以采用一个父进程专门accept，父进程均衡的分配多个子进程分别处理一部分的链接，子进程采用select模型监测自己负责的fd的可读可写。 

2.epoll模型

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

LT(level triggered)水平触发，是缺省的工作方式，并且同时支持block和no-block socket。只要buffer里有未被处理的事件，内核会不断通知你就绪未处理的FD。

ET(edge-triggered)边缘触发，是高速工作方式，只支持no-block socket。只在buffer大小发生变化时通知，只通知一次。

#include<sys/socket.h>

#include<sys/wait.h>

#include<netinet/in.h>

#include<netinet/tcp.h>

#include<sys/epoll.h>

#include<sys/sendfile.h>

#include<sys/stat.h>

#include<unistd.h>

#include<stdio.h>

#include<stdlib.h>

#include <string.h>

#include<strings.h>

#include<fcntl.h>

#include<errno.h>

 

#define MAX_EVENTS 10

#define PORT 8080

 

//设置socket连接为非阻塞模式

void setnonblocking(intsockfd) {

    int opts;

 

    opts = fcntl(sockfd, F_GETFL);

    if(opts < 0) {

        perror("fcntl(F_GETFL)\n");

        exit(1);

    }

    opts = (opts | O_NONBLOCK);

    if(fcntl(sockfd, F_SETFL, opts) < 0) {

        perror("fcntl(F_SETFL)\n");

        exit(1);

    }

}

 

int main(){

    struct epoll_event ev, events[MAX_EVENTS];

    int addrlen, listenfd, conn_sock, nfds, epfd,fd, i, nread, n;

    struct sockaddr_in local, remote;

    char buf[BUFSIZ];

 

    //创建listen socket

    if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

        perror("sockfd\n");

        exit(1);

    }

    setnonblocking(listenfd);

    bzero(&local, sizeof(local));

    local.sin_family = AF_INET;

    local.sin_addr.s_addr = htonl(INADDR_ANY);;

    local.sin_port = htons(PORT);

    if( bind(listenfd, (structsockaddr *) &local, sizeof(local)) < 0) {

        perror("bind\n");

        exit(1);

    }

    listen(listenfd, 20);

 

    epfd = epoll_create(MAX_EVENTS);

    if (epfd == -1) {

        perror("epoll_create");

        exit(EXIT_FAILURE);

    }

 

    ev.events = EPOLLIN;

    ev.data.fd = listenfd;

    if (epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd,&ev) == -1) {

        perror("epoll_ctl: listen_sock");

        exit(EXIT_FAILURE);

    }

 

    for (;;) {

        nfds = epoll_wait(epfd, events,MAX_EVENTS, -1);

        if(nfds == -1) {

            perror("epoll_pwait");

            exit(EXIT_FAILURE);

        }

 

        for (i= 0; i < nfds; ++i) {

            fd = events[i].data.fd;

            if (fd== listenfd) {

                while((conn_sock = accept(listenfd,(struct sockaddr *) &remote,

                    (size_t *)&addrlen))> 0) {

                       setnonblocking(conn_sock);

                        ev.events = EPOLLIN |EPOLLET;

                        ev.data.fd = conn_sock;

                        if (epoll_ctl(epfd, EPOLL_CTL_ADD, conn_sock,

                            &ev) == -1) {

                                perror("epoll_ctl: add");

                                exit(EXIT_FAILURE);

                        }

                }

                if(conn_sock == -1) {

                    if(errno != EAGAIN && errno != ECONNABORTED

                        && errno !=EPROTO && errno != EINTR)

                        perror("accept");

                }

                continue;

            } 

            if(events[i].events & EPOLLIN) {

                n = 0;

                while((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {

                    n += nread;

               }

                if(nread == -1 && errno != EAGAIN) {

                    perror("read error");

                }

                ev.data.fd = fd;

                ev.events = events[i].events |EPOLLOUT;

                if(epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {

                    perror("epoll_ctl: mod");

                }

            }

            if(events[i].events & EPOLLOUT) {

                sprintf(buf, "HTTP/1.1 200 OK\r\nContent-Length:%d\r\n\r\nHello World", 11);

                intnwrite, data_size = strlen(buf);

                n = data_size;

                while (n> 0) {

                    nwrite = write(fd, buf +data_size - n, n);

                    if(nwrite < n) {

                        if (nwrite == -1 && errno != EAGAIN) {

                            perror("write error");

                        }

                        break;

                    }

                    n -= nwrite;

                }

                close(fd);

            }

        }

    }

 

    return0;

}

  epoll模式的特点： 
1.支持进程打开的最大文件描述符，很好的解决了C10K问题；
2.IO效率不随FD数目增加而线性下降，epoll不是通过轮询，而是通过在等待的描述符上注册回调函数，当事件发生时，回调函数负责把发生的事件存储在就绪事件链表中，最后写到用户空间；
3.使用mmap加速内核与用户空间的消息传递。
4.内核微调

3.总结

      在连接少而且都活跃的情况下，使用select模型效果很好；而epoll在高并发量的处理上表现更优秀。