EPOLLONESHOT及其引发的EPOLL在ET能被多次触发吗？

 

以下是《Linux高性能服务器编程》对EPOLLONESHOT的描述：

对于注册了EPOLLONESHOT的文件描述符，操作系统最多触发其上注册的一个可读、可写或者异常的事件，且只触发一次，除非我们使用epoll_ctl函数重置该文件描述符上注册的EPOLLONESHOT事件。

 

乍一看会以为EPOLLONESHOT不就是ET模式相对于LT模式的区别，仔细阅读之后发现原来ET和EPOLLONESHOT是不同的。

区别时：ET是可读、可写、异常事件中的每一种只能被触发一次，就是说这三种不同的事件都是能被触发的只不过只能一次而已。而EPOLLONESHOT是所有的这些事件总共只能被触发一次。

再仔细阅读，发现书上在介绍EPOLLONESHOT时说其是为了应对ET模式下同种事件可能会被触发多次的情况。这就引发了一个问题。那就是：

ET模式能被同种事件触发多次吗？什么情况才会多次触发呢？ 

思路一：数据之间时间间隔过大？

验证：发送大量数据，但是并没有出现ET模式多次触发的情况。

思路二：和接受缓冲区有关？默认的接受缓冲区太大使用setsockopt的SO_RCVBUF选项了调小接受缓冲区试试。

验证：调小缓冲区后果然出现了ET多次触发得情况。

服务端程序：

 #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 <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 2500
//将文件描述符设置成非阻塞的
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;
}
//将文件描述符的EPOLLIN注册到epollfd指示的epoll内核事件表中，参数enable_et指定是否对fd启动ET模式。
void addfd( int epollfd, int fd, bool enable_et )
{
	//event用于描述事件类型（读入、读出、是否LET、）。
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN;
    if( enable_et )
    {
        event.events |= EPOLLET;
    }
    epoll_ctl( epollfd, EPOLL_CTL_ADD, fd, &event );
    setnonblocking( fd );
}


/*就绪事件就存在这个events数组里面了，number是事件数，遍历number个事件，确定其类型并处理就好了*/
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 );
            addfd( epollfd, connfd, true );
        }
        else if ( events[i].events & EPOLLIN )
        {
            printf( "et event trigger once\n" );
            while( 1 )
            {
                memset( buf, '\0', BUFFER_SIZE );
                int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
                if( ret < 0 )
                {
                    if( ( errno == EAGAIN ) || ( errno == EWOULDBLOCK ) )
                    {
                        printf( "read later\n" );
                        break;
                    }
                    close( sockfd );
                    break;
                }
                else if( ret == 0 )
                {
                    close( sockfd );
                }
                else
                {
                    //printf( "get %d bytes of content: %s\n", ret, buf );
					printf("get %d byte data,………………\n",ret);
                }
            }
        }
        else
        {
            printf( "something else happened \n" );
        }
    }
}

int main( int argc, char* argv[] )
{
    if( argc <= 2 )
    {
        printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
        return 1;
    }
    const 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 );
	/*----------这一段是自己添加的用于修改接受缓冲区的大小----------*/
	/*
	（1）此处我将缓冲区大小设为1250，实际上系统会将其加倍即实际缓冲区大小是2500，
	但是接收数据的时候还是1250字节，Why？
	（2）缓冲区也不是随便设的在/proc/sys/net/ipv4/tcp_rmem中有[min default max]的信息。
	我的环境默认的接受缓冲区大小是87380字节，实际上最小限制是2304字节。
	*/
	int recvbuf = 1250;
	int len = sizeof(int);
	setsockopt(listenfd, SOL_SOCKET, SO_RCVBUF, &recvbuf, sizeof(int));
	getsockopt(listenfd, SOL_SOCKET, SO_RCVBUF, &recvbuf, (socklen_t*)&len);
	printf("the receive buffer size after settting is %d\n", recvbuf);

    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 )
        {
            printf( "epoll failure\n" );
            break;
        }
        et( events, ret, epollfd, listenfd );
    }
    close( listenfd );
    return 0;
}

客户端程序：

#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 <string.h>
#include <stdlib.h>
#include <poll.h>
#include <fcntl.h>
#include <iostream>
#include <string>
using namespace std;

int main(int argc, char* argv[])
{
	if (argc <= 2)
	{
		printf("usage: %s ip_address port_number\n", basename(argv[0]));
		return 1;
	}
	const 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)
	{
		printf("connection failed\n");
		close(sockfd);
		return 1;
	}
	else {
		/*此处发送10000字节的数据*/
		char str[10000];
		memset(str, 'a', 10000);
		send(sockfd, str,strlen(str),0);
	}
	close(sockfd);
	return 0;
}

结果如下：

 

综上所述：EPOLL的ET模式即时针对同一种事件也是有可能引起多次触发的。

对于读事件系统读缓冲区溢出时就会引起多次触发；对于写事件系统写缓冲区溢出时同样会引起多次触发。

 

接下来说说这个EPOLLONESHOT：

作用：保证同一时刻一个socket仅被一个线程处理。（不同时刻可以有不同线程处理）

前面说了eppll 即使使用ET模式，一个socket上的某个事件还是可能被触发多次。如果采用线程池的方式来处理事件，可能一个socket同时被多个线程处理。例如：在线程池技术中每次有触发事件就将其添加到任务队列中，线程池中的线程去竞争任务队列里面的任务（生产者/消费者模式）。显然如果某个线程在读取完某个socket上的数据后开始处理这些数据，而在数据的处理过程中该socket上又有新的可读数据（EPOLLIN再次被触发），此时另外一个线程被唤醒在读取这些新的数据。于是就出现了两个线程同时操作一个socket的局面。显然这不是我们所期望的。

EPOLL的EPOLLONESHOT事件，使一个socket连接任何时刻都只被一个线程所处理对于注册了EPOLLONESHOT事件的socket，操作系统最多触发其上注册的一个可读、可写、或者异常事件，且只触发一次。这样，当一个线程在处理某个socket时，其他线程是不可能有机会操作该socket的，但反过来，注册了EPOLLONESHOT事件的socket一旦被某个线程处理完毕，该线程就应该立即重置这个socket上的EPOLLONESHOT事件，以确保这个socket下一次可读，其EPOLLIN事件能被触发，其他工作线程有机会继续处理这个socket。由此看来，尽管一个socket在不同时刻可能被不同的线程处理，但同一时刻肯定只有一个线程再为它服务，这就保证了连接的完整性，从而避免了很多可能的竞态条件。

EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里 

例子：

        epoll_event event;

        event..data.fd=fd;

        evnet.events=EPOLLIN | EPOLLT |EPOOLLONESHOT

       epoll_ctl( epollfd,EPOLL_CTL_ADD , fd , &event );// 第一次添加

 

epoll_wait 返回， 处理fd的读事件，一直读一直读，读到没有数据 （ errno==EAGAIN） ，这时才重置fd上的事件 

 

        epoll_event event;

        event..data.fd=fd;

        evnet.events=EPOLLIN | EPOLLT |EPOOLLONESHOT

       epoll_ctl( epollfd,EPOLL_CTL_MOD , fd , &event );