前幾天和同學一起討論EPOLLONESHOT的作用，它的功能是這樣的:

對於註冊了EPOLLONESHOT事件的檔案描述符，作業系統最多觸發其上註冊的包括可讀，可寫，錯誤中的一個，且只觸發一次

剛一看感覺EPOLLONESHOT咋麼就是ET模式相對於LT模式的區別，反覆理解之後發現原來ET和ONESHOT的區別是ET只是可讀可寫或錯誤類的某一種事件型別只能被觸發一次，而不同種類的事件型別卻可以觸發不止一次。難道僅僅是這個區別麼，如果只是這樣，我感覺給給事件型別加個ONESHOT還不如只用ET呢，好像這樣也並沒什麼大問題。

又經過仔細讀之後，我發現書上在介紹EPOLLONESHOT時說其是為了應對ET模式下同種事件可能會被觸發多次的情況。這下我明白了ONESHOT的作用了，但是我卻更加奇怪，ET模式下咋麼會同種事件被觸發多次呢？
後來我想會不會是傳送方傳送的資料中由於一些原因導致其中的一部分和另一部分發送來的時間有很大(注意這個很大也不是很大，你懂得)的間隔.那麼咋樣才可能出現這種情況呢，當然你每次傳送的資料越大出現這種機率的可能也就越大，所以為此我寫了程式碼進行了測試，但是發現測了好多也沒出現ET被觸發多次的現象
最後我想了下會不會是因為系統預設的接收緩衝區給的太大了？於是我將緩衝區改為500位元組大小，然後send一次send100000資料，果不其然，這次ET模式下，可讀被觸發了40多次

具體測試情況如下:
server端

#include<iostream>
#include<vector>
#include<algorithm>
#include<numeric>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#include<stdio.h>
#include<unistd.h>
 

#include<errno.h>
#include<string.h>
#include<fcntl.h>
#include<sys/epoll.h>
#include<pthread.h>
using namespace std;

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10
int SUM = 0;

//設定檔案描述符為非阻塞
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;

}


//新增fd到epoll核心事件表並選擇是否開啟ET模式
void addfd(int epoll_fd,int fd,bool enable_et)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLERR;
    if(enable_et)
    {
        //開啟et模式
        event.events |= EPOLLET;
    }

    epoll_ctl(epoll_fd,EPOLL_CTL_ADD,fd,&event);
    setnonblocking(fd);

}


//ET模式
void et(epoll_event *events,int number,int epollfd,int listenfd)
{
    char buf[BUFFER_SIZE];


    for(int i=0;i<number;i++)
    {
        int sockfd = events[i].data.fd;

        if(sockfd == listenfd)
        {
            struct sockaddr_in client_address;
            socklen_t client_addrlength = sizeof(client_address);
            int connfd = accept(listenfd,(struct sockaddr *)&client_address,&client_addrlength);

            //xiugai
            int on = 500;
            //設定接收緩衝區大小為500
            setsockopt(connfd,SOL_SOCKET,SO_RCVBUF,(void *)&on,sizeof(int));
            addfd(epollfd,connfd,true);
        }
        else if(events[i].events & EPOLLIN)
        {
            SUM++;
            while(1)
            {
                bzero(buf,BUFFER_SIZE);
                int ret = recv(sockfd,buf,BUFFER_SIZE-1,0);
                if(ret < 0)
                {
                    //對於非阻塞I/O，下面條件成立表示資料已經全部讀取完畢，此後epoll就能再一次觸發sockfd上的EPOLLIN事件，以驅動下次讀操作
                    if((errno == EAGAIN) || (errno == EWOULDBLOCK))
                    {
                        cout<<"read later\n";
                        break;
                    }
                    close(sockfd);
                    break; 
                }
                else if(ret == 0)
                {
                    close(sockfd);
                }
                else
                {
                    cout<<"get "<<ret<<" bytes of content "<<buf<<endl;

                }    
            }

            cout<<"times:"<<SUM<<endl;
        }
        else
        {
            cout<<"something else happened\n";
        }
    }
}


int main(int argc,char **argv)
{
    if(argc <= 2)
    {
        cout<<"引數錯誤"<<endl;
    }
    char *ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in address;
    bzero(&address,sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET,ip,&address.sin_addr);
    address.sin_port = htons(port);

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

    ret = bind(listenfd,(struct sockaddr *)&address,sizeof(address));
    assert(ret != -1);
    ret = listen(listenfd,5);
    assert(ret != -1);

    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);
    addfd(epollfd,listenfd,true);

    while(1)
    {

        int ret = epoll_wait(epollfd,events,MAX_EVENT_NUMBER,-1);

        if(ret < 0)
        {
            cout<<"epoll failure"<<endl;
            break;
        }

        //使用et模式
        et(events,ret,epollfd,listenfd);

    }
    close(listenfd);
    return 0;
}

client端

#include<iostream>
#include<vector>
#include<algorithm>
#include<numeric>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
using namespace std;
int main(int argc,char **argv)
{
    if(argc <= 2)
    {
        cout<<"您輸入的引數有誤";
        return 1;
    }

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

    struct sockaddr_in server_address;
    bzero(&server_address,sizeof(server_address));
    server_address.sin_family = AF_INET;
    inet_pton(AF_INET,ip,&server_address.sin_addr);
    server_address.sin_port = htons(port);

    int sockfd = socket(PF_INET,SOCK_STREAM,0);
    assert(sockfd >= 0);
    if(connect(sockfd,(struct sockaddr *)&server_address,sizeof(server_address)) < 0)
    {
        cout<<"error"<<endl;
    }

    else
    {
        string str1(100000,'a');


            int ret = send(sockfd,str1.c_str(),str1.size(),0);

            cout<<"ret"<<ret<<endl;

    }

    sleep(10);
    return 0;
}

伺服器執行結果截圖

從圖中可以看出EPOLLIN被觸發了48次，所以我們就知道了EPOLL的ET模式會在接收緩衝區溢位時，可能發生被觸發多次的情況