以下是《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模式即时针对同一种事件也是有可能引起多次触发的。例如对于可读事件读缓冲区溢出时就会引起反复触发。