UNIX網絡編程：I/O復用技術(select、poll、epoll)

Unix下可用的I/O模型一共有五種：阻塞I/O 、非阻塞I/O 、I/O復用 、信號驅動I/O 、異步I/O。此處我們主要介紹第三種I/O符復用。
I/O復用的功能：如果一個或多個I/O條件滿足（輸入已准備好讀，或者描述字可以承接更多輸出）時，我們就被通知到。這就是有select、poll、epoll實現。

I/O復用應用場合：
1、當客戶處理多個描述字時（一般是交互式輸入和網絡套接口），必須使用I/O復用。在這前一段中已做描述。
2、一個客戶同時處理多個套接口是可能的，但很少出現。
3、如果一個TCP服務器機要處理監聽套接口，有要處理已連接套接口，一般也要用到I/O復用。
4、如果一個服務器機要處理TCP，有要處理UDP，一般也要使用I/O復用。
5、如果一個服務器要處理多個服務或者多個協議，一般要使用I/O復用。

I/O復用原理圖：

select:
使用Select就可以完成非阻塞（所謂非阻塞方式non-block，就是進程或線程執行此函數時不必非要等待事件的發生，一旦執行肯定返回，以返回值的不同來反映函數的執行情況，如果事件發生則與阻塞方式相 同，若事件沒有發生則返回一個代碼來告知事件未發生，而進程或線程繼續執行，所以效率較高）方式工作的程序，它能夠監視我們需要監視的文件描述符的變化情 況——讀寫或是異常。

所要用到的結構體：
struct timeval{
long tv_sec; //等待的秒數
long tv_usec; //等待的微秒數
}

select()函數：
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
作用：用來檢測描述符中是否有准備好讀、寫、或異常的描述符
參數1(nfds)：被測試的描述字個數；它的值為要被測試的最大描述符個 數+1，而描述字0，1，2，……..，nfds-1；
參數2—4 (readfds)、(writefds)、(exceptfds)：這三個參數指定我們要讓內核測試讀、寫、異常條件所需的描述字。當我們在調用該函數，指定好我們所要檢測的描述字集後，如果檢測三種情況下任何一中情況准備好，則將相應的狀態變為可用狀態。如果到達函數返回時沒有可讀可寫則返回失敗。如果我們不關心其中哪個狀態，可將其設為NULL。
參數5(timeout)：指定等待時間，有三種情況：
(1)、永遠等待下去(參數timeout設置為空指針)：僅在有一個描述字准備好I/O時才返回。
(2)、等待固定時間(指定timeval中的秒數和微秒數)：在不超過timeval結構體中所指定的秒數和微秒數內檢測到有一個描述字准備好I/O時返回
(3)、根本不等待(timeval中秒數和微秒數均設置為0)：檢查描述字後立即返回。

select工作原理：
select就是巧妙的利用等待隊列機制讓用戶進程適當在沒有資源可讀/寫時睡眠，有資源可讀/寫時喚醒。下面我們看看select睡眠的詳細過程。

select會循環遍歷它所監測的fd_set(一組文件描述符(fd)的集合）內的所有文件描述符對應的驅動程序的poll函數。驅動程序提供的poll函數首先會將調用select的用戶進程插入到該設備驅動對應資源的等待隊列(如讀/寫等待隊列)，然後返回一個bitmask告訴select當前資源哪些可用。當select循環遍歷完所有fd_set內指定的文件描述符對應的poll函數後，如果沒有一個資源可用(即沒有一個文件可供操作)，則select讓該進程睡眠，一直等到有資源可用為止，進程被喚醒(或者timeout)繼續往下執行。

select調用過程：

頭文件：下面poll、epoll的頭文件與該文件相同

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define IPADDR  "192.168.3.169"
#define PORT    8787
#define MAXLINE 1024
#define LISTENQ 5

//select
#define SIZE 10
//poll
#define OPEN_SIZE 10
//epoll
#define FDSIZE 100

服務器端：

#include"../unp.h"
#include

typedef struct server_context_st   //服務器描述表
{
    int cli_cnt;                   //客戶端連接個數
    int clifds[SIZE];              //描述字集合
    fd_set allfds;                 //設置所有的描述字
    int maxfd;                     //最大描述字個數
}server_context_st;

static server_context_st *s_srv_ctx = NULL;         

int server_init()                          //服務器初始化函數
{
    s_srv_ctx = (server_context_st*)malloc(sizeof(server_context_st));          //申請一個服務器描述表
    if(s_srv_ctx == NULL)
        return -1;
    memset(s_srv_ctx, 0, sizeof(server_context_st));                            //將該描述表清0
    for(int i=0; iclifds[i] = -1;
    }
    return 0;
}
void server_uninit()                      //服務器去初始化函數
{
    if(s_srv_ctx)                         //如果服務器描述表不為0，即該表申請成功存在
    {
        free(s_srv_ctx);                  //釋放該表的內存
        s_srv_ctx = NULL;                 //將指針值為NULL。
    }
}

int create_server_proc(const char *ip, short port)     //創建服務器進程
{
    int fd;                                          
    fd = socket(AF_INET, SOCK_STREAM, 0);              //建立一個套接字，記錄返回的描述字，
    if(fd == -1)                                       //檢測是否創建成功
    {
        perror("socket");
        return -1;
    }
    //初始化服務器信息結構體
    struct sockaddr_in addrSer;
    addrSer.sin_family = AF_INET;                         //指定用到的協議族
    addrSer.sin_port = htons(port);                       //指定服務器端口號
    addrSer.sin_addr.s_addr = inet_addr(ip);              //指定服務器ip地址

    socklen_t addrlen = sizeof(struct sockaddr);
    int res = bind(fd, (struct sockaddr*)&addrSer, addrlen);     //將創建的描述字與剛才所設置的服務器信息綁定
    if(res == -1)                                                //檢測是否綁定成功嗯
    {
        perror("bind");
        return -1;
    }
    listen(fd, LISTENQ);       //監聽是否有客戶端請求連接，如果有則將該套接字設為可用
    return fd;
}

int accept_client_proc(int srvfd)             //結束客戶端連接請求
{
    struct sockaddr_in addrCli;
    socklen_t addrlen = sizeof(struct sockaddr);

    int clifd;
ACCEPT:
    clifd = accept(srvfd, (struct sockaddr*)&addrCli, &addrlen);      //結束客戶端的連接請求
    if(clifd == -1)                    //判斷是否連接成功
    {
        goto ACCEPT;                   //如果沒有連接成功，則跳轉至ACCEPT處繼續連接
    }
    printf("accept a new client: %s:%d\n",inet_ntoa(addrCli.sin_addr),addrCli.sin_port);

    int i;
    for(i=0; iclifds[i] == -1)        //如果描述字為-1，表明只連接了i個客戶端（0 —— i-1）
        {
            s_srv_ctx->clifds[i] = clifd;     //則將連接描述字賦給服務器描述表中第i個描述字
            s_srv_ctx->cli_cnt++;             //已連接的客戶端數量加一
            break;
        }
    }
    if(i == SIZE)                             //如果i等於SIZE，說明描述字集合已滿
    {
        printf("Server Over Load.\n");        
        return -1;
    }
}

void handle_client_msg(int fd, char *buf)     //處理接收到的客戶端信息函數
{
    printf("recv buf is:> %s\n",buf);         //服務器將接收到的來自客戶端的信息打印出來
    send(fd, buf, strlen(buf)+1, 0);          //向客戶端發送信息
}

void recv_client_msg(fd_set *readfds)        //接收客戶端信息
{
    int clifd; 
    char buffer[256];
    int n;
    for(int i=0; icli_cnt; ++i)        //輪尋查找（從描述字集合的第一個描述字開始到最後一個已連接的客戶端）
    {
        clifd = s_srv_ctx->clifds[i];              
        if(clifd < 0)                              //如果套接字小於0，則失敗
            continue;
        if(FD_ISSET(clifd, readfds))               //將該描述字設置為可讀
        {
           n = recv(clifd, buffer, 256, 0);        //接收來自客戶端的信息
           if(n <= 0)                              //如果返回址小於等於0則接收失敗，說明客戶端已斷開連接
           {
               FD_CLR(clifd, &s_srv_ctx->allfds);  //將描述字清0
               close(clifd);                       //關閉這個描述字
               s_srv_ctx->clifds[i] = -1;          //將第i個描述字設為-1（i為已連接的客戶端個數-1）
               s_srv_ctx->cli_cnt--;               //將以連接的客戶端個數減一
               continue;
           }

           handle_client_msg(clifd, buffer);       //調用處理客戶端信息函數，來處理即接收到的信息

        }
    }
}

int handle_client_proc(int srvfd)                //客戶端處理程序
{
    int clifd = -1;                              //將客戶端描述字設置為-1
    int retval = 0;
    fd_set *readfds = &s_srv_ctx->allfds;        //讓可讀指針指向描述字
    struct timeval tv;                           

    while(1)
    {
        FD_ZERO(readfds);                        //清除可讀描述字指針
        FD_SET(srvfd, readfds);                  //用srvfd設置readfds
        s_srv_ctx->maxfd = srvfd;                //設置最大描述符個數
        tv.tv_sec = 30;                          //設置時間結構體中的秒與微秒
        tv.tv_usec = 0;

        int i;
        for(i=0; icli_cnt; ++i)          //遍歷已經連接的客戶端
        {
            clifd = s_srv_ctx->clifds[i];           
            FD_SET(clifd, readfds);                  //將他們的描述字設置為可讀
            s_srv_ctx->maxfd = (clifd > s_srv_ctx->maxfd ? clifd : s_srv_ctx->maxfd);  //選取兩個中較大的一個作為最大描述字個數
        }

        retval = select(s_srv_ctx->maxfd+1, readfds, NULL, NULL, &tv);      //檢測是否有准備好的I/O接口
        if(retval == -1)              //如果沒有則檢測失敗
        {
            perror("select");
            return -1;
        }
        if(retval == 0)                    //如果返回址為0則檢測超時
        {
            printf("server time out.\n");
            continue;
        }

        //accept
        if(FD_ISSET(srvfd, readfds))  //如果該位是作為描述字的
        {
            accept_client_proc(srvfd);   //接收客戶端的連接
        }
        else                            //如果是作為可讀指針的
        {
            recv_client_msg(readfds);     //則接收客戶端信息
        }
    }
}

int main(int argc, char *argv[])
{
    int sockSer;
    if(server_init() < 0)                            //檢測服務器描述表是否初始化失敗
        perror("server_init");
    sockSer = create_server_proc(IPADDR, PORT);      //創建一個服務器進程
    if(sockSer < 0)                                  //檢測服務器服務是否創建失敗
    {
        perror("create_server_porc");
        goto err;
    }
    handle_client_proc(sockSer);                     //處理客戶端
    return 0;
err:
    server_uninit();                                //去初始化服務器描述表
    return -1;
}

客戶端：

#include"../unp.h"

void handle_connection(int sockfd)              //連接處理函數
{
    fd_set readfds;            
    int maxfd = sockfd;                         //描述字最大個數
    struct timeval tv;
    while(1)
    {
        FD_ZERO(&readfds);                     //將可讀描述字空間清0
        FD_SET(sockfd, &readfds);              //用套接字設置可讀描述字空間
        maxfd = sockfd;                        //設置最大描述字個數
        tv.tv_sec = 5;                         //設置時間結構體中的秒數
        tv.tv_usec = 0;                        //設置時間結構體中的微秒數

        int res = select(maxfd+1, &readfds, NULL, NULL, &tv);   //等待可讀的描述字
        if(res == -1)                       //如果函數返回時沒有可讀I/O准備好
        {
            perror("select");               //則檢測失敗
            return;
        }
        if(res == 0)                        //如果返回值為0
        {
            printf("Client time out.\n");   //則表明檢測超時
            continue;
        }
        int n;
        char recvbuf[256];
        if(FD_ISSET(sockfd, &readfds))             
        {
            n = recv(sockfd,recvbuf, 256, 0);      //接收來自服務器的信息
            if(n <= 0)                             //如果返回的讀取長度小於0，則表明服務器已經關閉
            {
                printf("Server is closed.\n");       
                close(sockfd);                     //關閉套接字描述符
                FD_CLR(sockfd, &readfds);          //清除描述字可讀標識為
                return;
            }
            printf("client recv slef msg:> %s\n",recvbuf);    //打印客戶端接收到的信息
            sleep(3);
            send(sockfd, recvbuf, strlen(recvbuf)+1, 0);      //發送信息
        }
    }
}

int main()
{
    int sockCli;
    sockCli = socket(AF_INET, SOCK_STREAM, 0);     //創建一個套接字
    struct sockaddr_in addrSer;                   
    addrSer.sin_family = AF_INET;                  //設置通信所用到的協議族
    addrSer.sin_port = htons(PORT);                //指定通信端口號
    addrSer.sin_addr.s_addr = inet_addr(IPADDR);   //指定ip地址

    socklen_t addrlen = sizeof(struct sockaddr);
    int res = connect(sockCli, (struct sockaddr*)&addrSer, addrlen);     //連接服務器已客戶端
    if(res < 0)                                                       //連接失敗
        perror("connect");
    printf("Client connect Server Ok.\n");
    send(sockCli,"hello Server.",strlen("hello Server.")+1, 0);         //給服務器發送數據，此處為了方便用固定值
    handle_connection(sockCli);                         //處理連接
    return 0;
}

運行結果：

select幾點不足：
（1）每次調用select，都需要把fd集合從用戶態拷貝到內核態，這個開銷在fd很多時會很大
（2）同時每次調用select都需要在內核遍歷傳遞進來的所有fd，這個開銷在fd很多時也很大
（3）select支持的文件描述符數量太小了，默認是1024

poll:
poll的機制與select類似，與select在本質上沒有多大差別，管理多個描述符也是進行輪詢，根據描述符的狀態進行處理，但是poll沒有最大文件描述符數量的限制。poll和select同樣存在一個缺點就是，包含大量文件描述符的數組被整體復制於用戶態和內核的地址空間之間，而不論這些文件描述符是否就緒，它的開銷隨著文件描述符數量的增加而線性增大。
使用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()就像它的名字那樣，一旦選舉出來，立即返回。

pollfd結構體：
struct pollfd{
int fd; //文件描述符
short events; //等待的事件
short revents; //實際發生了的事件
}

poll函數：
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
作用：返回准備好的描述字的個數。
參數1：struct pollfd結構體用來指定一個被監聽的文件描述符
參數2：nfds_t類型的參數，用於標記數組fds中的結構體元素的總數量；
參數3：是poll函數調用阻塞的時間，單位：毫秒；

用poll實現客戶端與服務器之間的通信：（頭文件與select相同）
客戶端程序：

#include "../unp.h"

void handle_connection(int sockfd)        //連接處理函數
{
    pollfd fds[2];
    fds[0].fd = sockfd;                   //讓第一個描述字設為創建套接字的描述符
    fds[0].events = POLLIN;               //把第一個描述字設置為普通或優先級帶數據可讀
    fds[1].fd = STDIN_FILENO;             //把第二個檢驗描述字設置為標准文件輸入
    fds[1].events = POLLIN;               //把第二個描述字事件標志設置為普通或優先級帶數據可讀

    int n;
    char buf[256];
    for(; ;){                            
        poll(fds, 2, -1);                      //無限等待，因為POSIX標准裡並沒有INFTIM，所以用-1          
        if(fds[0].revents & POLLIN){           //如果fd[0]中事件已經發生並且為普通或優先級帶數據可讀，表明客戶端可讀
            n = recv(sockfd, buf, 256, 0);     //則接收來自服務器哦的數據
            if(n <= 0){                        //如果接收到的數據長度小於0，則表明服務器已經關閉
                 printf("Server is Closed.\n");
                 close(sockfd);
            }
            write(STDOUT_FILENO, buf, n);      //標准輸出，打印出接收大的來自服務器的信息
        }
        if(fds[1].revents & POLLIN){           //如果fd[0]中事件已經發生並且為標准輸入，表明客戶端可寫
            n = read(STDIN_FILENO, buf, 256);  //讀取鍵盤輸入的內容
            if(n == 0){                        //如果沒有地到輸入的內容，則繼續
                continue;
            }
            write(sockfd, buf, n);             //將從鍵盤獲得的數據寫入套接字描述符中
        }
    }
}

int main()
{
    int sockCli;
    sockCli = socket(AF_INET, SOCK_STREAM, 0);     //創建一個套接字
    struct sockaddr_in addrSer;
    addrSer.sin_family = AF_INET;                  //規定通信協議族
    addrSer.sin_port = htons(PORT);                //設置所用端口號
    addrSer.sin_addr.s_addr = inet_addr(IPADDR);   //設置服務器ip

    connect(sockCli, (struct sockaddr*)&addrSer, sizeof(struct sockaddr));       //創建連接

    handle_connection(sockCli);        //調用處理客戶端連接函數

    return 0;
}

服務器端程序：

#include "../unp.h"
#include 

int sock_bind(const char *ip, short port)            //綁定處理函數
{
    int fd;
    fd = socket(AF_INET, SOCK_STREAM, 0);            //創建一個套接字
    struct sockaddr_in addrSer;
    addrSer.sin_family = AF_INET;                    //設置所用到的協議族
    addrSer.sin_port = htons(port);                  //規定所用到的端口號
    addrSer.sin_addr.s_addr = inet_addr(ip);         //設置ip號

    socklen_t addrlen = sizeof(struct sockaddr);    
    bind(fd, (struct sockaddr*)&addrSer, addrlen);    //綁定套接字描述符和地址結構體信息

    return fd;
}

void handle_connection(struct pollfd *connfds, int num)     //連接處理函數
{
    int n;
    char buf[256];
    for(int i = 1; i <= num; ++i){                        //輪尋
        if(connfds[i].fd == -1){                          //如果fd額日-1，則繼續執行
            continue;
        }
        if(connfds[i].revents & POLLIN){                  //如果該描述字有事件發生並且時普通或優先級數據可讀
            n = recv(connfds[i].fd, buf, 256, 0);         //則接收來自客戶端的數據
            if(n <= 0){                                   //如果接收到的數據常速小於0，說明客戶端退出
                close(connfds[i].fd);                     //關閉連接描述符
                connfds[i].fd = -1;                       
                continue;
            }
            printf("recv msg:>%s\n", buf);                //打印接收到的來自客戶端的信息
            send(connfds[i].fd, buf, n, 0);               //發送服務器的信息
        }
    }
}

void do_poll(int sockSer)
{
    pollfd clientfds[OPEN_SIZE];                  //定義一個存放描述字的數組
    clientfds[0].fd = sockSer;                    //讓fd[0]的描述字設置為創建的套接字描述符
    clientfds[0].events = POLLIN;                 //將其事件設置為普通或優先級帶數據

    for(int i = 1; i < OPEN_SIZE; ++i){          //將數組內所有的描述字設置為-1
        clientfds[i].fd = -1;
    }

    int maxi = 0;
    int nready;
    struct sockaddr_in addrCli;              
    socklen_t addrlen = sizeof(struct sockaddr);
    int i;   

    for(; ;){
        nready = poll(clientfds, maxi+1, -1);       //等待准備好的描述字
        if(nready == -1){                           //如果返回值為-1則表明查找失敗
            perror("poll");
            exit(1);
        }
        if(clientfds[0].revents & POLLIN){          //如果clientfd[0]有事件發生，並且為POLLIN，則接收連接
            int sockConn = accept(sockSer, (struct sockaddr*)&addrCli, &addrlen);  //接收客戶端連接請求

            if(sockConn == -1){         //檢測返回值，判斷是否連接成功
                perror("accept");
                continue;
            }
            //打印連接信息
            printf("accept a new client:%s:%d\n", inet_ntoa(addrCli.sin_addr), addrCli.sin_port);

            for(i = 1; i < OPEN_SIZE; ++i){       //找到還沒有標志連接的描述字，將連接返回的描述符給他
                if(clientfds[i].fd < 0){
                    clientfds[i].fd = sockConn;
                    break;
                }
            }
            if(i == OPEN_SIZE){                   //如果數組內所有描述字都標志連接，則說明連接的客戶端數量已夠
                printf("Server Over Load.\n");
                continue;
            }
            clientfds[i].events = POLLIN;         //將該描述字的事件設為POLLIN
            maxi = (i > maxi ? i : maxi);         //如果此時連接數已經超過描述字的最大個數，則更改最大值，否則不變
            if(--nready <= 0){
                continue;
            }
        }
        handle_connection(clientfds, maxi);   //調用連接處理函數
    }
}

int main()
{
    int sockSer;
    sockSer = sock_bind(IPADDR, PORT);       //服務器信息的綁定
    listen(sockSer, LISTENQ);                //監聽等待隊列有沒有客戶端申請連接
    do_poll(sockSer);                        //do_epoll函數,來處理信息傳遞

    return 0;
}

epoll:
epoll對文件描述符的操作有兩種模式：LT（level trigger）和ET（edge trigger）。LT模式是默認模式，LT模式與ET模式的區別如下：
　　LT模式：當epoll_wait檢測到描述符事件發生並將此事件通知應用程序，應用程序可以不立即處理該事件。下次調用epoll_wait時，會再次響應應用程序並通知此事件。
　　ET模式：當epoll_wait檢測到描述符事件發生並將此事件通知應用程序，應用程序必須立即處理該事件。如果不處理，下次調用epoll_wait時，不會再次響應應用程序並通知此事件。　

首先，通過epoll_create(int maxfds)來創建一個epoll的句柄，其中maxfds為你epoll所支持的最大句柄數。這個函數會返回一個新的epoll句柄，之後的所有操作將通過這個句柄來進行操作。在用完之後，記得用close()來關閉這個創建出來的epoll句柄。

然後，在你的網絡主循環裡面，每一幀的調用epoll_wait(int epfd, epoll_event* events, int max events, int timeout)來查詢所有的網絡接口，看哪一個可以讀，哪一個可以寫了。基本的語法為：nfds = epoll_wait(kdpfd, events, maxevents, -1);
其中kdpfd為用epoll_create創建之後的句柄，events是一個epoll_event*的指針，當epoll_wait這個函數操作成功之後， events裡面將儲存所有的讀寫事件。max_events是當前需要監聽的所有socket句柄數。最後一個timeout是 epoll_wait的超時，為0的時候表示馬上返回，為-1的時候表示一直等下去，直到有事件范圍，為任意正整數的時候表示等這麼長的時間，如果一直沒有事件，則返回。一般如果網絡主循環是單獨的線程的話，可以用-1來等，這樣可以保證一些效率，如果是和主邏輯在同一個線程的話，則可以用0來保證主循環的效率。

events可以是以下幾個宏的集合：
EPOLLIN ：表示對應的文件描述符可以讀（包括對端SOCKET正常關閉）；
EPOLLOUT：表示對應的文件描述符可以寫；
EPOLLPRI：表示對應的文件描述符有緊急的數據可讀（這裡應該表示有帶外數據到來）；
EPOLLERR：表示對應的文件描述符發生錯誤；
EPOLLHUP：表示對應的文件描述符被掛斷；
EPOLLET： 將EPOLL設為邊緣觸發(Edge Triggered)模式，這是相對於水平觸發(Level Triggered)來說的。
EPOLLONESHOT：只監聽一次事件，當監聽完這次事件之後，如果還需要繼續監聽這個socket的話，需要再次把這個socket加入到EPOLL隊列裡。

用epoll代替select/poll實現代碼：
服務器端：

#include "../unp.h"
#include "utili.h"
#include 

int sock_bind(const char *ip, short port)          //綁定函數
{
    int fd;
    fd = socket(AF_INET, SOCK_STREAM, 0);          //創建一個套接字
    struct sockaddr_in addrSer;
    addrSer.sin_family = AF_INET;                  //設定所用的協議族
    addrSer.sin_port  = htons(port);               //設定所用到的端口號
    addrSer.sin_addr.s_addr = inet_addr(ip);       //設定服務器ip
    socklen_t addrlen = sizeof(struct sockaddr);

    return fd;
}

void handle_accept(int epollfd, int listenfd)      //結束連接函數
{
    struct sockaddr_in addrCli;
    int sockConn;
    socklen_t addrlen = sizeof(struct sockaddr);  
    sockConn = accept(listenfd, (struct sockaddr*) &addrCli, &addrlen);   //服務器接受客戶端的連接請求
    if(sockConn == -1){           //判斷是否接受成功
        perror("accept");
    }else{
        printf("accept a new client:%s:%d\n", inet_ntoa(addrCli.sin_addr), addrCli.sin_port);
        add_event(epollfd, sockConn, EPOLLIN);     //增加事件
    }
}

void do_read(int epollfd, int fd, char *buf)          //讀數據函數
{
    int nread = read(fd, buf, 256);                   //讀數據
    if(nread <= 0){                                   //如果獨到的數據長度小於0，則表明服務器關閉
        printf("Server is Closed.\n");
        close(fd);
        delete_event(epollfd, fd, EPOLLIN);           //刪除剛才添加的事件
    }
    printf("recv msg:>%s\n", buf);                    //如果接受成功，則打印出所接受到的內容
    modify_event(epollfd, fd, EPOLLOUT);              //設置事件列表為輸出
}

void do_write(int epollfd, int fd, char *buf)         //寫數據函數
{
    int nwrite = write(fd, buf, strlen(buf)+1);       //向緩存區中寫入數據
    if(nwrite <= 0){                                  //如果寫入數據長度小於0，說明客戶端關閉
        printf("client is closed.\n");
        close(fd);
        delete_event(epollfd, fd, EPOLLOUT);          //刪除所添加的事件
    }else{
        modify_event(epollfd, fd, EPOLLIN);           //如果寫入成功則設置事件列表為輸入
    }
}

void handle_events(int epollfd, epoll_event *events, int num, int listenfd, char *buf)   //事件處理函數
{
    int fd;
    for(int i = 0; i < num; ++i){        //將所有描述字遍歷一遍
        fd = events[i].data.fd;          
        if((fd == listenfd) && (events[i].events & EPOLLIN)){    //判斷如果描述字處於監聽狀態，並且有事件准備好並且為EPOLLIN
            handle_accept(epollfd, listenfd);              //則調用接受連接函數
        }else if(events[i].events & EPOLLIN){              //如果不處於監聽狀態，並且有事件准備好且為EPOLLIN
            do_read(epollfd, fd, buf);                     //則調用讀處理函數
        }else if(events[i].events & EPOLLOUT){             //如果不處於監聽狀態，並且有事件准備好且為EPOLLOUT
            do_write(epollfd, fd, buf);                    //則調用寫處理函數
        }
    }
}

void do_epoll(int listenfd)         
{
    int epollfd;
    epoll_event events[1024];                     //事件列表
    epollfd = epoll_create(FDSIZE);               //創建一個epoll句柄
    add_event(epollfd, listenfd, EPOLLIN);        //將EPOLLIN添加到事件列表中
    int res;
    char buf[256];

    for(; ;){
        res = epoll_wait(epollfd, events, 1024, -1);     //等待事件列表中的事件准備好
        if(res == -1){                                   //判斷是否有事件准備好
            perror("epoll_wait");
            exit(1);
        }
        handle_events(epollfd, events, res, listenfd, buf);    //調用事件處理函數
    }
    close(epollfd);          //關閉描述字
}

int main()
{
    int listenfd;
    listenfd = sock_bind(IPADDR, PORT);   //調用綁定函數
    listen(listenfd, LISTENQ);         //監聽是否有客戶端請求連接
    do_epoll(listenfd);                //調用do_epoll函數

    return 0;
}

客戶端：

#include "../unp.h"
#include "utili.h"

void do_read(int epollfd, int fd, int sockfd, char *buf)   //讀處理函數
{
    int nread;
    nread = read(fd, buf, 256);       //讀數據
    if(nread == -1){                  //如果讀到的數據長度為-1，則顯示讀錯誤信息
        perror("read");
        close(fd);                    //關閉描述字
    }else if(nread == 0){             //如果讀數據返回值為0，則表明服務器關閉
        printf("Server is close.\n");
        close(fd);
        exit(1);
    }else{
        if(fd == STDIN_FILENO){        //如果描述字為標准輸入
              add_event(epollfd, sockfd, EPOLLOUT);   //則在事件列表中增加EPOLLOUT
        }else{       
              delete_event(epollfd, fd, EPOLLIN);     //否則刪除事件列表中的事件EPOLLIN
        }
    }
    printf("recv msg:>%s\n", buf);         //打印接收到的信息
    modify_event(epollfd, fd, EPOLLFD)     //設置事件為EPOLLIN
}

void do_write(int epollfd, int fd, int sockfd, char *buf){    //寫處理函數
    int nwrite;
    nwrite = write(fd, buf, strlen(buf)+1, 0);      //向緩存區中寫入數據
    if(nwrite == -1){             //判斷是否寫入失敗
        perror("write");
        close(fd);
    }
}

void handle_events(int epollfd, epoll_event *events, int num, int sockfd, char *buf)     //事件處理函數
{
    int fd;
    for(int i = 0; i < num; ++i){        //將描述字遍歷一遍
        fd = events[i].dsts.fd;
        if(events[i].events & EPOLLIN){      //如果有事件准備好並且為EPOLLIN，
            do_read(epollfd, fd, sockfd, buf);  //則調用讀操作函數
        }else if(events[i].events & EPOLLOUT){   //額uguo有事件准備好並且為EPOLLOUT
            do_write(epollfd, fd, sockfd, buf);   //則調用寫操作函數
        }
    }
}

void handle_connection(int sockfd)        //連接處理函數
{
    char buf[256];
    int epollfd;
    epoll_event events[1024];           //事件列表
    epollfd = epoll_create(FDSIZE);     //創建一個epoll句柄
    ad_event(epollfd, STDIN_FILENO, EPOLLIN);  //增加事件EPOLLIN
    int res;

    for(; ;){
        res = epoll_wait(epollfd, events, 1024, -1);       //等待事件列表中存在的事件准備好
        handle_events(epollfd, events, res, sockfd, buf);  //調用事件處理函數
    }
    close(epollfd);      //關閉描述字
}

int main()
{
    int sockCli;
    sockCli = socket(AF_INET, SOCK_STREAM, 0);      //創建套接字
    struct sockaddr_in addrSer;
    addrSer.sin_family = AF_INET;                   //設置協議族
    addrSer.sin_port = htons(PORT);                 //設置端口號
    addrSer.sin_addr.s_addr = inet_addr(IPADDR);    //設置ip號

    connect(sockCli, (struct sockaddr *)&addrSer, sizeof(struct sockaddr));      //連接服務器與客戶端

    handle_connection(sockCli);         //調用連接處理函數，進行連接後的相關操作

    return 0;
}

總結：
（1）select，poll實現需要自己不斷輪詢所有fd集合，直到設備就緒，期間可能要睡眠和喚醒多次交替。而epoll其實也需要調用epoll_wait不斷輪詢就緒鏈表，期間也可能多次睡眠和喚醒交替，但是它是設備就緒時，調用回調函數，把就緒fd放入就緒鏈表中，並喚醒在epoll_wait中進入睡眠的進程。雖然都要睡眠和交替，但是select和poll在“醒著”的時候要遍歷整個fd集合，而epoll在“醒著”的時候只要判斷一下就緒鏈表是否為空就行了，這節省了大量的CPU時間。這就是回調機制帶來的性能提升。
（2）select，poll每次調用都要把fd集合從用戶態往內核態拷貝一次，並且要把current往設備等待隊列中掛一次，而epoll只要一次拷貝，而且把current往等待隊列上掛也只掛一次（在epoll_wait的開始，注意這裡的等待隊列並不是設備等待隊列，只是一個epoll內部定義的等待隊列）。這也能節省不少的開銷。