UNIX实现IO多路复用之使用epoll函数实现网络socket服务端

一，前言

UNIX下存在五种网络模型，分别是：同步阻塞IO，同步非阻塞IO，信号驱动IO，异步IO和今天要介绍的IO多路复用。

那么IO多路复用解决的问题是什么呢？

我们知道在UNIX下的很多函数都是阻塞的,阻塞是指IO操作在没有接收完数据或者没有得到结果之前不 会返回，需要彻底完成后才返回到用户空间；假设我们现在面临这样一个问题：我们需要在一个程序里要查看按键是否要按下，同时他还要从串口里读取数据进行处理，也要处理网络上来的数据，如果只是普通的利用三个read调用来解决，如果按键这时没按下(即数据没有准备好)read()系统调用不会返回在那，即使现在串口或网 络socket有数据到来也没法处理，我们可以采用多线程的方式来做这个问题，但是并比较耗内存和cpu，所以今天我们来浅浅的学习一下IO多路复用模型下的epoll函数吧！

二，关于poll（select，poll和epoll的比较）

在linux 没有实现epoll事件驱动机制之前，我们一般选择用select或者poll等IO多路复用的方法来实现并发服务程序。自Linux 2.6内核正式引入epoll以来，epoll已经成为了目前实现高性能网络服务器的必备技术，在大数据、高并发、集群等一些名词唱得火热之年代，select和poll的用武之地越来越有限，风头已经被epoll占尽。

而select存在很多缺点：

1. 单个进程能够监视的文件描述符的数量存在最大限制，通常是1024，当然可以更改数量，但由于select采用轮询的方式扫描文件描述符，文件描述符数量越多，性能越差；

2. 内核 / 用户空间内存拷贝问题，select需要复制大量的句柄数据结构，产生巨大的开销；

3. select返回的是含有整个句柄的数组，应用程序需要遍历整个数组才能发现哪些句柄发生了事件；

4. select的触发方式是水平触发，应用程序如果没有完成对一个已经就绪的文件描述符进行IO操作，那么之后每次select调用还是会将这些文件描述符通知进程。

相比select模型，poll 使用链表保存文件描述符，因此没有了监视文件数量的限制，但其他三个缺点依然存在。拿select模型为例，假设我们的服务器需要支持100万的并发连接，则在__FD_SETSIZE 为1024的情况下，则我们至少需要开辟1k个进程才能 实现100万的并发连接。除了进程间上下文切换的时间消耗外，从内核/用户空间大量的无脑内存拷贝、数组轮询等，是系统难以 承受的。因此，基于select模型的服务器程序，要达到10万级别的并发访问，是一个很难完成的任务。

epoll是Linux内核为处理大批量文件描述符而作了改进的poll ，是Linux下多路复用IO接口select/poll的增强版本，它能显著 提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。epoll除了提供select/poll那种IO事 件的水平触发（Level Triggered）外，还提供了边缘触发（Edge Triggered），这就使得用户空间程序有可能缓存IO状态，减 少epoll_wait/epoll_pwait的调用，提高应用程序效率。

由于 epoll的实现机制与select/poll机制完全不同 ，上面所说的 select的缺点在epoll上不复存在。设想一下如下场景：有100万个客户端同时与一个服务器进程保持着TCP连接。而每一时刻，通常只有几百上千个TCP连接是活跃的(事实上大部分场景都是这种情况)。如何实现这样的高并发？在select/poll时代，服务器进程每次都把这100万个连接告诉操作系统(从用户态复制句柄数据结构到内核态)，让操作系统内核去查询这些套接字上是否有事件发生，轮询完后，再将句柄数据复制到用户态，让服务器应用程序轮询处理已发生的网络事件，这一过程资源消耗较大，因此，select/poll一般只能处理几千的并发连接。

epoll的设计 和实现与select完全不同。epoll通过在Linux内核中申请一个简易的文件系统，把原先的select/poll调用分成了 3个部分：

1. 调用epoll_create()建立一个epoll对象(在epoll文件系统中为这个句柄对象分配资源)。

2. 调用epoll_ctl向epoll对象中添加这100万个连接的套接字。

3. 调用epoll_wait收集发生的事件的连接  。

如此一来，要实现上面说是的场景，只需要在进程启动时建立一个epoll对象，然后在需要的时候向这个epoll对象中添加或者删除连接。同时，epoll_wait的效率也非常高，因为调用epoll_wait时，并没有一股脑的向操作系统复制这100万个连接的句柄数

据，内核也不需要去遍历全部的连接。

三，epoll相关函数

1，创建epoll实例：epoll_create()

#include <sys/epoll.h>
int epoll_create(int size);

系统调用epoll_create()创建了一个新的epoll实例，其对应的兴趣列表初始化为空。若成功返回文件描述符，若出错返回-1。
参数size指定了我们想要通过epoll实例来检查的文件描述符个数。该参数并不是一个上限，而是告诉内核应该如何为内部数据结构划分初始大小。从Linux2.6.8版以来，size参数被忽略不用。

作为函数返回值，epoll_create()返回了代表新创建的epoll实例的文件描述符。这个文件描述符在其他几个epoll系统调用中用来表示epoll实例。当这个文件描述符不再需要时，应该通过close（）来关闭。当所有与epoll实例相关的文件描述符都被关闭时，实例被销毁，相关的资源都返还给系统。从2.6.27版内核以来，Linux支持了一个新的系统调用epoll_create1()。该系统调用执行的任务同epoll_create()一样，但是去掉了无用的参数size，并增加了一个可用来修改系统调用行为的flags参数。目前只支持一个flag标志：EPOLL_CLOEXEC，它使得内核在新的文件描述符上启动了执行即关闭标志。

2，修改epoll的兴趣列表：epoll_ctl()

#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);
/*系统调用epoll_ctl()能够修改由文件描述符epfd所代表的epoll实例中的兴趣列表。
若成功返回0，若出错返回-1。*/

第一个参数epfd是epoll_create()的返回值；

第二个参数op 用来指定需要执行的操作，它可以是如下几种值：

EPOLL_CTL_ADD： 将描述符fd添加到epoll实例中的兴趣列表中去。对于fd上我们感兴趣的事件，都指定在ev所指向的结构体中。如果我们试图向兴趣列表中添加一个已存在的文件描述符，epoll_ctl()将出现EEXIST错误；

EPOLL_CTL_MOD： 修改描述符上设定的事件，需要用到由ev所指向的结构体中的信息。如果我们试图修改不在兴趣列表中的文件描述符，epoll_ctl()将出现ENOENT错误；

EPOLL_CTL_DEL： 将文件描述符fd从epfd的兴趣列表中移除，该操作忽略参数ev。如果我们试图移除一个不在epfd的兴趣列表中的文件描述符，epoll_ctl()将出现ENOENT错误。关闭一个文件描述符会自动将其从所有的epoll实例的兴趣列表移除；

第三个参数fd 指明了要修改兴趣列表中的哪一个文件描述符的设定。该参数可以是代表管道、FIFO、套接字、POSIX消息队列、inotify实例、终端、设备，甚至是另一个epoll实例的文件描述符。但是，这里fd不能作为普通文件或目录的文件描述符；

第四个参数ev 是指向结构体epoll_event的指针，结构体的定义如下：

 

typedef union epoll_data
{
 void *ptr; /* Pointer to user-defind data */
 int fd; /* File descriptor */
 uint32_t u32; /* 32-bit integer */
 uint64_t u64; /* 64-bit integer */
} epoll_data_t;

struct epoll_event
{
 uint32_t events; /* epoll events(bit mask) */
 epoll_data_t data; /* User data */
}

参数ev为文件描述符fd所做的设置（epoll_event）如下：、

events字段 是一个位掩码，它指定了我们为待检查的描述符fd上所感兴趣的事件集合；

data字段 是一个联合体，当描述符fd稍后称为就绪态时，联合的成员可用来指定传回给调用进程的信息；

3，事件等待：epoll_wait()

#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event *evlist, int maxevents, int timeout);

系统调用epoll_wait()返回epoll实例中处于就绪态的文件描述符信息，
单个epoll_wait()调用能够返回多个就绪态文件描述符的信息。

调用成功后epoll_wait()返回数组evlist中的元素个数，
如果在timeout超时间隔内没有任何文件描述符处于就绪态的话就返回0，
出错时返回-1并在errno中设定错误码以表示错误原因。

第一个参数epfd 是epoll_create()的返回值；

第二个参数evlist 所指向的结构体数组中返回的是有关就绪态文件描述符的信息，数组evlist的空间由调用者负责申请；

第三个参数maxevents 指定所evlist数组里包含的元素个数；

第四个参数timeout 用来确定epoll_wait()的阻塞行为，有如下几种：

如果timeout等于-1 ，调用将一直阻塞，直到兴趣列表中的文件描述符上有事件产生或者直到捕获到一个信号为止。

如果timeout等于0 ，执行一次非阻塞式地检查，看兴趣列表中的描述符上产生了哪个事件。

如果timeout大于0 ，调用将阻塞至多timeout毫秒，直到文件描述符上有事件发生，或者直到捕获到一个信号为止。

数组evlist中 ，每个元素返回的都是单个就绪态文件描述符的信息。events字段返回了在该描述符上已经发生的事件掩码。

data字段 返回的是我们在描述符上使用epoll_ctl()注册感兴趣的事件时在ev.data中所指定的值。注意，data字段是唯一可获知同这个事件相关的文件描述符的途径。因此，当我们调用epoll_ctl()将文件描述符添加到感兴趣列表中时，应该要么将ev.date.fd设为文件描述符号，要么将ev.date.ptr设为指向包含文件描述符号的结构体。

当我们调用epoll_ctl()时可以在ev.events中指定的位掩码以及由epoll_wait()返回的evlist[].events中的值如下所示：

默认情况下，一旦通过epoll_ctl()的EPOLL_CTL_ADD操作将文件描述符添加到epoll实例的兴趣列表中后，它会保持激活状态 （即，之后对epoll_wait()的调用会在描述符处于就绪态时通知我们）直到我们显示地通过epoll_ctl()的EPOLL_CTL_DEL操作将 其从列表中移除。如果我们希望在某个特定的文件描述符上只得到一次通知，那么可以在传给epoll_ctl()的ev.events中指定

EPOLLONESHOT标志。如果指定了这个标志，那么在下一个epoll_wait()调用通知我们对应的文件描述符处于就绪态之后，这个描述符就会在兴趣列表中被标记为非激活态，之后的epoll_wait()调用都不会再通知我们有关这个描述符的状态了。如果需要，我们可以稍后用过调用epoll_ctl()的EPOLL_CTL_MOD操作重新激活对这个文件描述符的检查。

 

 

四，用epoll实现网络socket编程之服务端（代码含详细注释）

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include <pthread.h>
#include <getopt.h>
#include <libgen.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <sys/resource.h>
#define MAX_EVENTS 512
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))

static inline void print_usage(char *progname);
int socket_server_init(char *listen_ip, int listen_port);
void set_socket_rlimit(void);

int main(int argc, char **argv)
{
    int      listenfd, connfd;
    int      serv_port = 0;
    int      daemon_run = 0;
    char    *progname = NULL;
    int      opt;
    int      rv;
    int      i, j;
    int      found;
    char     buf[1024];
    int      epollfd;
    struct   epoll_event     event;
    struct   epoll_event     event_array[MAX_EVENTS];
    int      events;
 
    struct option long_options[] ={ 
                                      {"daemon", no_argument, NULL, 'b'},
                                      {"port", required_argument, NULL, 'p'},
                                      {"help", no_argument, NULL, 'h'},
                                      {NULL, 0, NULL, 0}
                                  }; progname = basename(argv[0]);
 
    while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1)
    { 
        switch (opt)
        { 
            case 'b':
                daemon_run=1;
                 break;
            case 'p':
                serv_port = atoi(optarg);
                break;
            case 'h': 
                print_usage(progname);
                return EXIT_SUCCESS;
                default:
                break;
        } 
    } 
    if( !serv_port )
    { 
        print_usage(progname);
        return -1;
    }
    set_socket_rlimit(); //调用函数set_sock_rlimit,可为无数多个客户端服务；
    if( (listenfd=socket_server_init(NULL, serv_port)) < 0 )
    {
        printf("ERROR: %s server listen on port %d failure\n", argv[0],serv_port);
        return -2;
    }
    printf("%s server start to listen on port %d\n", argv[0],serv_port);

    if( daemon_run )
    {
        daemon(0, 0);
    }
    if( (epollfd=epoll_create(MAX_EVENTS)) < 0 )//调用epoll_creat函数；
    {
        printf("epoll_create() failure: %s\n", strerror(errno));//出错处理；
        return -3;
    }
 /*写入event.events = EPOLLIN|EPOLLET;*/
    event.events = EPOLLIN;
    event.data.fd = listenfd;
    if( epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event) < 0)//将listenfd添加到epollfd中的兴趣列表里面去；
    {
        printf("epoll add listen socket failure: %s\n", strerror(errno));
        return -4;
    }
    for ( ; ; )//死循环；
    {
        events = epoll_wait(epollfd, event_array, MAX_EVENTS, -1);//调用epoll_wait函数，返回数组event_array里面的元素个数；
        if(events < 0)
        {
            printf("epoll failure: %s\n", strerror(errno));//出错处理；
            break;
        }
        else if(events == 0)
        {
            printf("epoll get timeout\n");
            continue;
        }
 /* rv>0时有两个事件处理：处理连接事件和处理已连接事件 */
        for(i=0; i<events; i++)
        {
            if ( (event_array[i].events&EPOLLERR) || (event_array[i].events&EPOLLHUP) )//如果有错误发生；
            {
                printf("epoll_wait get error on fd[%d]: %s\n", event_array[i].data.fd, strerror(errno));
                epoll_ctl(epollfd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);//将event_array[i].data.fd从epollfd中删除；
                close(event_array[i].data.fd);
            }
 /* 处理连接事件 */
            if( event_array[i].data.fd == listenfd )//如果是我要找的listenfd；
            {
                if( (connfd=accept(listenfd, (struct sockaddr *)NULL, NULL)) < 0)
                {
                    printf("accept new client failure: %s\n", strerror(errno));
                    continue;
                }
                event.data.fd = connfd;
                event.events = EPOLLIN;
                if( epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &event) < 0 )//如果connfd加入epollfd错误；
                {
                    printf("epoll add client socket failure: %s\n", strerror(errno));
                    close(event_array[i].data.fd);
                    continue;
                }
                printf("epoll add new client socket[%d] ok.\n", connfd);
            }
            
            /*处理已连接的客户端事件*/
            else 
            {
                if( (rv=read(event_array[i].data.fd, buf, sizeof(buf))) <= 0)
                {
                    printf("socket[%d] read failure or get disconncet and will be removed.\n",event_array[i].data.fd);
                    epoll_ctl(epollfd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
                    close(event_array[i].data.fd);
                    continue;
                }
                else
                {
                    printf("socket[%d] read get %d bytes data\n", event_array[i].data.fd, rv);
                  
                  /*对buf中的事件进行操作*/
                    for(j=0; j<rv; j++)
                    buf[j]=toupper(buf[j]);
                    if( write(event_array[i].data.fd, buf, rv) < 0 )
                    {
                        printf("socket[%d] write failure: %s\n", event_array[i].data.fd, strerror(errno));
                        epoll_ctl(epollfd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
                        close(event_array[i].data.fd);
                    }
                }
            }
        } /* for(i=0; i<rv; i++) */
    } /* while(1) */
    CleanUp:
    close(listenfd);
    return 0;
}

static inline void print_usage(char *progname)
{
    printf("Usage: %s [OPTION]...\n", progname);
    printf(" %s is a socket server program, which used to verify client and echo back string from it\n",progname);
    printf("\nMandatory arguments to long options are mandatory for short options too:\n");
    printf(" -b[daemon ] set program running on background\n");
    printf(" -p[port ] Socket server port address\n");
    printf(" -h[help ] Display this help information\n");
    printf("\nExample: %s -b -p 8900\n", progname);
    return ;
}

int socket_server_init(char *listen_ip, int listen_port)
{
    struct sockaddr_in servaddr;
    int rv = 0;
    int on = 1;
    int listenfd;
    if ( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        printf("Use socket() to create a TCP socket failure: %s\n", strerror(errno));
        return -1;
    }
 
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET; 
    servaddr.sin_port = htons(listen_port);
    if( !listen_ip ) 
    {
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
    }
    else 
    {
        if (inet_pton(AF_INET, listen_ip, &servaddr.sin_addr) <= 0)
        {
            printf("inet_pton() set listen IP address failure.\n");
            rv = -2;
            goto CleanUp;
        }
    }
    if(bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
    {
        printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
        rv = -3;
        goto CleanUp;
    }
    if(listen(listenfd, 64) < 0)
    {
        printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
        rv = -4;
        goto CleanUp;
    }
    CleanUp:
    if(rv<0)
    close(listenfd);
    else
    rv = listenfd;
    return rv;
}

/* 编写函数set_sock_rlimit让程序为无数多个客户端服务；*/
void set_socket_rlimit(void)
{
    struct rlimit limit = {0};
    getrlimit(RLIMIT_NOFILE, &limit );
    limit.rlim_cur = limit.rlim_max;
    setrlimit(RLIMIT_NOFILE, &limit );
    printf("set socket open fd max count to %ld\n", limit.rlim_max);
}

五，结果截图

客户端：

 

服务端：