【引用】很幽默的讲解六种Socket IO模型

 本文简单介绍了当前Windows支持的各种Socket I/O模型，如果你发现其中存在什么错误请务必赐教。 

 一：select模型 
 二：WSAAsyncSelect模型 
 三：WSAEventSelect模型 
 四：Overlapped I/O 事件通知模型 
 五：Overlapped I/O 完成例程模型 
 六：IOCP模型 

 老陈有一个在外地工作的女儿，不能经常回来，老陈和她通过信件联系。他们的信会被邮递员投递到他们的信箱里。 
 这和Socket模型非常类似。下面我就以老陈接收信件为例讲解Socket I/O模型~~~ 

 一：select模型 

 老陈非常想看到女儿的信。以至于他每隔10分钟就下楼检查信箱，看是否有女儿的信~~~~~ 
 在这种情况下，"下楼检查信箱"然后回到楼上耽误了老陈太多的时间，以至于老陈无法做其他工作。 
 select模型和老陈的这种情况非常相似：周而复始地去检查......如果有数据......接收/发送....... 

 使用线程来select应该是通用的做法： 
 procedure TListenThread.Execute; 
 var 
 addr : TSockAddrIn; 
 fd_read : TFDSet; 
 timeout : TTimeVal; 
 ASock, 
 MainSock : TSocket; 
 len, i : Integer; 
 begin 
 MainSock := socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); 
 addr.sin_family := AF_INET; 
 addr.sin_port := htons(5678); 
 addr.sin_addr.S_addr := htonl(INADDR_ANY); 
 bind( MainSock, @addr, sizeof(addr) ); 
 listen( MainSock, 5 ); 

 while (not Terminated) do 
 begin 
 FD_ZERO( fd_read ); 
 FD_SET( MainSock, fd_read ); 
 timeout.tv_sec := 0; 
 timeout.tv_usec := 500; 
 if select( 0, @fd_read, nil, nil, @timeout ) > 0 then //至少有1个等待Accept的connection 
 begin 
 if FD_ISSET( MainSock, fd_read ) then 
 begin 
 for i:=0 to fd_read.fd_count-1 do //注意，fd_count <= 64，也就是说select只能同时管理最多64个连接 
 begin 
 len := sizeof(addr); 
 ASock := accept( MainSock, addr, len ); 
 if ASock <> INVALID_SOCKET then 
 ....//为ASock创建一个新的线程，在新的线程中再不停地select 
 end; 
 end; 
 end; 
 end; //while (not self.Terminated) 

 shutdown( MainSock, SD_BOTH ); 
 closesocket( MainSock ); 
 end; 

 二：WSAAsyncSelect模型 

 后来，老陈使用了微软公司的新式信箱。这种信箱非常先进，一旦信箱里有新的信件，盖茨就会给老陈打电话：喂，大爷，你有新的信件了！从此，老陈再也不必频繁上下楼检查信箱了，牙也不疼了，你瞅准了，蓝天......不是，微软~~~~~~~~ 
 微软提供的WSAAsyncSelect模型就是这个意思。 

 WSAAsyncSelect模型是Windows下最简单易用的一种Socket I/O模型。使用这种模型时，Windows会把网络事件以消息的形势通知应用程序。 
 首先定义一个消息标示常量： 
 const WM_SOCKET = WM_USER + 55; 
 再在主Form的private域添加一个处理此消息的函数声明： 
 private 
 procedure WMSocket(var Msg: TMessage); message WM_SOCKET; 
 然后就可以使用WSAAsyncSelect了： 
 var 
 addr : TSockAddr; 
 sock : TSocket; 

 sock := socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); 
 addr.sin_family := AF_INET; 
 addr.sin_port := htons(5678); 
 addr.sin_addr.S_addr := htonl(INADDR_ANY); 
 bind( m_sock, @addr, sizeof(SOCKADDR) ); 

 WSAAsyncSelect( m_sock, Handle, WM_SOCKET, FD_ACCEPT or FD_CLOSE ); 

 listen( m_sock, 5 ); 
 .... 

 应用程序可以对收到WM_SOCKET消息进行分析，判断是哪一个socket产生了网络事件以及事件类型： 

 procedure TfmMain.WMSocket(var Msg: TMessage); 
 var 
 sock : TSocket; 
 addr : TSockAddrIn; 
 addrlen : Integer; 
 buf : Array [0..4095] of Char; 
 begin 
 //Msg的WParam是产生了网络事件的socket句柄，LParam则包含了事件类型 
 case WSAGetSelectEvent( Msg.LParam ) of 
 FD_ACCEPT : 
 begin 
 addrlen := sizeof(addr); 
 sock := accept( Msg.WParam, addr, addrlen ); 
 if sock <> INVALID_SOCKET then 
 WSAAsyncSelect( sock, Handle, WM_SOCKET, FD_READ or FD_WRITE or FD_CLOSE ); 
 end; 

 FD_CLOSE : closesocket( Msg.WParam ); 
 FD_READ : recv( Msg.WParam, buf[0], 4096, 0 ); 
 FD_WRITE : ; 
 end; 
 end; 

 三：WSAEventSelect模型 

 后来，微软的信箱非常畅销，购买微软信箱的人以百万计数......以至于盖茨每天24小时给客户打电话，累得腰酸背痛，喝蚁力神都不好使~~~~~~ 
 微软改进了他们的信箱：在客户的家中添加一个附加装置，这个装置会监视客户的信箱，每当新的信件来临，此装置会发出"新信件到达"声，提醒老陈去收信。盖茨终于可以睡觉了。 

 同样要使用线程： 
 procedure TListenThread.Execute; 
 var 
 hEvent : WSAEvent; 
 ret : Integer; 
 ne : TWSANetworkEvents; 
 sock : TSocket; 
 adr : TSockAddrIn; 
 sMsg : String; 
 Index, 
 EventTotal : DWORD; 
 EventArray : Array [0..WSA_MAXIMUM_WAIT_EVENTS-1] of WSAEVENT; 
 begin 
 ...socket...bind... 
 hEvent := WSACreateEvent(); 
 WSAEventSelect( ListenSock, hEvent, FD_ACCEPT or FD_CLOSE ); 
 ...listen... 

 while ( not Terminated ) do 
 begin 
 Index := WSAWaitForMultipleEvents( EventTotal, @EventArray[0], FALSE, WSA_INFINITE, FALSE ); 
 FillChar( ne, sizeof(ne), 0 ); 
 WSAEnumNetworkEvents( SockArray[Index-WSA_WAIT_EVENT_0], EventArray[Index-WSA_WAIT_EVENT_0], @ne ); 

 if ( ne.lNetworkEvents and FD_ACCEPT ) > 0 then 
 begin 
 if ne.iErrorCode[FD_ACCEPT_BIT] <> 0 then 
 continue; 

 ret := sizeof(adr); 
 sock := accept( SockArray[Index-WSA_WAIT_EVENT_0], adr, ret ); 
 if EventTotal > WSA_MAXIMUM_WAIT_EVENTS-1 then//这里WSA_MAXIMUM_WAIT_EVENTS同样是64 
 begin 
 closesocket( sock ); 
 continue; 
 end; 

 hEvent := WSACreateEvent(); 
 WSAEventSelect( sock, hEvent, FD_READ or FD_WRITE or FD_CLOSE ); 
 SockArray[EventTotal] := sock; 
 EventArray[EventTotal] := hEvent; 
 Inc( EventTotal ); 
 end; 

 if ( ne.lNetworkEvents and FD_READ ) > 0 then 
 begin 
 if ne.iErrorCode[FD_READ_BIT] <> 0 then 
 continue; 
 FillChar( RecvBuf[0], PACK_SIZE_RECEIVE, 0 ); 
 ret := recv( SockArray[Index-WSA_WAIT_EVENT_0], RecvBuf[0], PACK_SIZE_RECEIVE, 0 ); 
 ...... 
 end; 
 end; 
 end; 

 四：Overlapped I/O 事件通知模型 

 后 来，微软通过调查发现，老陈不喜欢上下楼收发信件，因为上下楼其实很浪费时间。于是微软再次改进他们的信箱。新式的信箱采用了更为先进的技术，只要用户告 诉微软自己的家在几楼几号，新式信箱会把信件直接传送到用户的家中，然后告诉用户，你的信件已经放到你的家中了！老陈很高兴，因为他不必再亲自收发信件 了！ 

 Overlapped I/O 事件通知模型和WSAEventSelect模型在实现上非常相似，主要区别在"Overlapped"，Overlapped模型是让应用程序使用重叠数据结构(WSAOVERLAPPED)，一次投递一个或多个Winsock I/O请求。这些提交的请求完成后，应用程序会收到通知。什么意思呢？就是说，如果你想从socket上接收数据，只需要告诉系统，由系统为你接收数据，而你需要做的只是为系统提供一个缓冲区~~~~~ 
 Listen线程和WSAEventSelect模型一模一样，Recv/Send线程则完全不同： 
 procedure TOverlapThread.Execute; 
 var 
 dwTemp : DWORD; 
 ret : Integer; 
 Index : DWORD; 
 begin 
 ...... 

 while ( not Terminated ) do 
 begin 
 Index := WSAWaitForMultipleEvents( FLinks.Count, @FLinks.Events[0], FALSE, RECV_TIME_OUT, FALSE ); 
 Dec( Index, WSA_WAIT_EVENT_0 ); 
 if Index > WSA_MAXIMUM_WAIT_EVENTS-1 then //超时或者其他错误 
 continue; 

 WSAResetEvent( FLinks.Events[Index] ); 
 WSAGetOverlappedResult( FLinks.Sockets[Index], FLinks.pOverlaps[Index], @dwTemp, FALSE, FLinks.pdwFlags[Index]^ ); 

 if dwTemp = 0 then //连接已经关闭 
 begin 
 ...... 
 continue; 
 end else 
 begin 
 fmMain.ListBox1.Items.Add( FLinks.pBufs[Index]^.buf ); 
 end; 

 //初始化缓冲区 
 FLinks.pdwFlags[Index]^ := 0; 
 FillChar( FLinks.pOverlaps[Index]^, sizeof(WSAOVERLAPPED), 0 ); 
 FLinks.pOverlaps[Index]^.hEvent := FLinks.Events[Index]; 
 FillChar( FLinks.pBufs[Index]^.buf^, BUFFER_SIZE, 0 ); 

 //递一个接收数据请求 
 WSARecv( FLinks.Sockets[Index], FLinks.pBufs[Index], 1, FLinks.pdwRecvd[Index]^, FLinks.pdwFlags[Index]^, FLinks.pOverlaps[Index], nil ); 
 end; 
 end; 

 五：Overlapped I/O 完成例程模型 

 老陈接收到新的信件后，一般的程序是：打开信封----掏出信纸----阅读信件----回复信件......为了进一步减轻用户负担，微软又开发了一种新的技术：用户只要告诉微软对信件的操作步骤，微软信箱将按照这些步骤去处理信件，不再需要用户亲自拆信/阅读/回复了！老陈终于过上了小资生活！ 

 Overlapped I/O 完成例程要求用户提供一个回调函数，发生新的网络事件的时候系统将执行这个函数： 
 procedure WorkerRoutine( const dwError, cbTransferred : DWORD; const 
 lpOverlapped : LPWSAOVERLAPPED; const dwFlags : DWORD ); stdcall; 
 然后告诉系统用WorkerRoutine函数处理接收到的数据： 
 WSARecv( m_socket, @FBuf, 1, dwTemp, dwFlag, @m_overlap, WorkerRoutine ); 
 然后......没有什么然后了，系统什么都给你做了！微软真实体贴！ 
 while ( not Terminated ) do//这就是一个Recv/Send线程要做的事情......什么都不用做啊！！！ 
 begin 
 if SleepEx( RECV_TIME_OUT, True ) = WAIT_IO_COMPLETION then // 
 begin 
 ; 
 end else 
 begin 
 continue; 
 end; 
 end; 

 六：IOCP模型 

 微软信箱似乎很完美，老陈也很满意。但是在一些大公司情况却完全不同！这些大公司有数以万计的信箱，每秒钟都有数以百计的信件需要处理，以至于微软信箱经常因超负荷运转而崩溃！需要重新启动！微软不得不使出杀手锏...... 
 微软给每个大公司派了一名名叫"Completion Port"的超级机器人，让这个机器人去处理那些信件！ 

 "Windows NT小组注意到这些应用程序的性能没有预料的那么高。特别的，处理很多同时的客户请求意味着很多线程并发地运行在系统中。因为所有这些线程都是可运行的[没有被挂起和等待发生什么事]，Microsoft意识到NT内核花费了太多的时间来转换运行线程的上下文[Context]，线程就没有得到很多CPU时间来做它们的工作。大家可能也都感觉到并行模型的瓶颈在于它为每一个客户请求都创建了一个新线程。创建线程比起创建进程开销要小，但也远不是没有开销的。我们不妨设想一下：如果事先开好N个线程，让它们在那hold[堵塞]，然后可以将所有用户的请求都投递到一个消息队列中去。然后那N个线程逐一从消息队列中去取出消息并加以处理。就可以避免针对每一个用户请求都开线程。不仅减少了线程的资源，也提高了线程的利用率。理论上很不错，你想我等泛泛之辈都能想出来的问题，Microsoft又怎会没有考虑到呢?"-----摘自nonocast的《理解I/O Completion Port》 

 先看一下IOCP模型的实现： 

 //创建一个完成端口 
 FCompletPort := CreateIoCompletionPort( INVALID_HANDLE_VALUE, 0,0,0 ); 

 //接受远程连接，并把这个连接的socket句柄绑定到刚才创建的IOCP上 
 AConnect := accept( FListenSock, addr, len); 
 CreateIoCompletionPort( AConnect, FCompletPort, nil, 0 ); 

 //创建CPU数2 + 2个线程 
 for i:=1 to si.dwNumberOfProcessors2+2 do 
 begin 
 AThread := TRecvSendThread.Create( false ); 
 AThread.CompletPort := FCompletPort;//告诉这个线程，你要去这个IOCP去访问数据 
 end; 

 OK，就这么简单，我们要做的就是建立一个IOCP，把远程连接的socket句柄绑定到刚才创建的IOCP上，最后创建n个线程，并告诉这n个线程到这个IOCP上去访问数据就可以了。 

 再看一下TRecvSendThread线程都干些什么： 

 procedure TRecvSendThread.Execute; 
 var 
 ...... 
 begin 
 while (not self.Terminated) do 
 begin 
 //查询IOCP状态（数据读写操作是否完成） 
 GetQueuedCompletionStatus( CompletPort, BytesTransd, CompletKey, POVERLAPPED(pPerIoDat), TIME_OUT ); 

 if BytesTransd <> 0 then 
 ....;//数据读写操作完成 

 //再投递一个读数据请求 
 WSARecv( CompletKey, @(pPerIoDat^.BufData), 1, BytesRecv, Flags, @(pPerIoDat^.Overlap), nil ); 
 end; 
 end; 

 读写线程只是简单地检查IOCP是否完成了我们投递的读写操作，如果完成了则再投递一个新的读写请求。 
 应该注意到，我们创建的所有TRecvSendThread都在访问同一个IOCP（因为我们只创建了一个IOCP），并且我们没有使用临界区！难道不会产生冲突吗？不用考虑同步问题吗？ 
 呵呵，这正是IOCP的奥妙所在。IOCP不是一个普通的对象，不需要考虑线程安全问题。它会自动调配访问它的线程：如果某个socket上有一个线程A正在访问，那么线程B的访问请求会被分配到另外一个socket。这一切都是由系统自动调配的，我们无需过问。
 深入了解epoll 
 一、 介绍 
 Epoll是一种高效的管理socket的模型，相对于select和poll来说具有更高的效率和易用性。传统的select以及poll的效率会因为socket数量的线形递增而导致呈二次乃至三次方的下降，而epoll的性能不会随socket数量增加而下降。标准的linux-2.4.20内核不支持epoll，需要打patch。本文主要从linux-2.4.32和linux-2.6.10两个内核版本介绍epoll。 
 二、 Epoll的使用 
 epoll用到的所有函数都是在头文件sys/epoll.h中声明的，下面简要说明所用到的数据结构和函数： 
 所用到的数据结构 
 typedef union epoll_data { 
                 void ptr; 
                 int fd; 
                 __uint32_t u32; 
                 __uint64_t u64; 
         } epoll_data_t; 

         struct epoll_event { 
                 __uint32_t events;      / Epoll events / 
                 epoll_data_t data;      / User data variable / 
         }; 
 结构体epoll_event 被用于注册所感兴趣的事件和回传所发生待处理的事件，其中epoll_data 联合体用来保存触发事件的某个文件描述符相关的数据，例如一个client连接到服务器，服务器通过调用accept函数可以得到于这个client对应的socket文件描述符，可以把这文件描述符赋给epoll_data的fd字段以便后面的读写操作在这个文件描述符上进行。epoll_event 结构体的events字段是表示感兴趣的事件和被触发的事件可能的取值为：EPOLLIN ：表示对应的文件描述符可以读； 
 EPOLLOUT：表示对应的文件描述符可以写； 
 EPOLLPRI：表示对应的文件描述符有紧急的数据可读 
 EPOLLERR：表示对应的文件描述符发生错误； 
 EPOLLHUP：表示对应的文件描述符被挂断； 
 EPOLLET：表示对应的文件描述符设定为edge模式； 
 所用到的函数： 
 1、epoll_create函数 
     函数声明：int epoll_create(int size) 
     该函数生成一个epoll专用的文件描述符，其中的参数是指定生成描述符的最大范围。在linux-2.4.32内核中根据size大小初始化哈希表的大小，在linux2.6.10内核中该参数无用，使用红黑树管理所有的文件描述符，而不是hash。 
 2、epoll_ctl函数 
     函数声明：int epoll_ctl(int epfd, int op, int fd, struct epoll_event event) 
     该函数用于控制某个文件描述符上的事件，可以注册事件，修改事件，删除事件。 
     参数：epfd：由 epoll_create 生成的epoll专用的文件描述符； 
                 op：要进行的操作例如注册事件，可能的取值 
 EPOLL_CTL_ADD 注册、 
 EPOLL_CTL_MOD 修改、 
 EPOLL_CTL_DEL 删除 
   fd：关联的文件描述符； 
   event：指向epoll_event的指针； 
   如果调用成功返回0,不成功返回-1 
 3、epoll_wait函数 
 函数声明:int epoll_wait(int epfd,struct epoll_event  events,int maxevents,int timeout) 
 该函数用于轮询I/O事件的发生； 
 参数： 
 epfd:由epoll_create 生成的epoll专用的文件描述符； 
 epoll_event:用于回传代处理事件的数组； 
 maxevents:每次能处理的事件数； 
 timeout:等待I/O事件发生的超时值（ms）；-1永不超时，直到有事件产生才触发，0立即返回。 
 返回发生事件数。-1有错误。 

 举一个简单的例子： 

 C/C++ codeint main()
 {
     //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
     struct epoll_event ev,events[20];

     epfd=epoll_create(10000);    //创建epoll句柄
     
     listenfd = socket(AF_INET, SOCK_STREAM, 0);
     //把socket设置为非阻塞方式
     setnonblocking(listenfd);
     
     bzero(&serveraddr, sizeof(serveraddr));
     serveraddr.sin_family = AF_INET;
     serveraddr.sin_addr.s_addr = INADDR_ANY;
     serveraddr.sin_port=htons(SERV_PORT);
     bind(listenfd,(struct sockaddr )&serveraddr, sizeof(serveraddr));
     listen(listenfd, 255);

     //设置与要处理的事件相关的文件描述符
     ev.data.fd=listenfd;
     //设置要处理的事件类型
     ev.events=EPOLLIN;
     //注册epoll事件
     epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);

     for ( ; ; )
     {
         //等待epoll事件的发生
         nfds=epoll_wait(epfd,events,20,1000);
         //处理所发生的所有事件
         for(i=0;i<nfds;++i)
         {
             if(events[i].data.fd==listenfd)
             {
                 connfd = accept(listenfd,(struct sockaddr )&clientaddr, &clilen);
                 if(connfd<0)
                 {
                     perror("connfd<0");
                 }
                 setnonblocking(connfd);
                 //设置用于读操作的文件描述符
                 ev.data.fd=connfd;
                 //设置用于注测的读操作事件
                 ev.events=EPOLLIN|EPOLLET;
                 //注册event
                 epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
             }
             else if(events[i].events&EPOLLIN)
             {
                 read_socket(events[i].data.fd);
                 ev.data.fd=events[i].data.fd;
                 ev.events=EPOLLIN|EPOLLOUT|EPOLLET;
                 epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
             }
             else if(events[i].events&EPOLLOUT)
             {
                 write_socket(events[i].data.fd);
                 ev.data.fd=events[i].data.fd;
                 ev.events=EPOLLIN|EPOLLET;    //ET模式
               epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
            }
             else
             {
                 perror("other event");
             }
         }
     }
 }

 
 Epoll的ET模式与LT模式 
 ET（Edge Triggered）与LT（Level Triggered）的主要区别可以从下面的例子看出 
 eg： 
 1． 标示管道读者的文件句柄注册到epoll中； 
 2． 管道写者向管道中写入2KB的数据； 
 3． 调用epoll_wait可以获得管道读者为已就绪的文件句柄； 
 4． 管道读者读取1KB的数据 
 5． 一次epoll_wait调用完成 
 如果是ET模式，管道中剩余的1KB被挂起，再次调用epoll_wait，得不到管道读者的文件句柄，除非有新的数据写入管道。如果是LT模式，只要管道中有数据可读，每次调用epoll_wait都会触发。 

 另一点区别就是设为ET模式的文件句柄必须是非阻塞的。 
 三、 Epoll的实现 
 Epoll的源文件在/usr/src/linux/fs/eventpoll.c，在module_init时注册一个文件系统eventpoll_fs_type，对该文件系统提供两种操作poll和release，所以epoll_create返回的文件句柄可以被poll、select或者被其它epoll epoll_wait。对epoll的操作主要通过三个系统调用实现： 
 1． sys_epoll_create 
 2． sys_epoll_ctl 
 3． sys_epoll_wait 
 下面结合源码讲述这三个系统调用。 
 1.1 long sys_epoll_create (int size) 
 该系统调用主要分配文件句柄、inode以及file结构。在linux-2.4.32内核中，使用hash保存所有注册到该epoll的文件句柄，在该系统调用中根据size大小分配hash的大小。具体为不小于size，但小于2size的2的某次方。最小为2的9次方（512），最大为2的17次方（128 x 1024）。在linux-2.6.10内核中，使用红黑树保存所有注册到该epoll的文件句柄，size参数未使用。 
 1.2 long sys_epoll_ctl(int epfd, int op, int fd, struct epoll_event event) 
 1． 注册句柄 op = EPOLL_CTL_ADD 
 注册过程主要包括： 
 A．将fd插入到hash（或rbtree）中，如果原来已经存在返回-EEXIST， 
 B．给fd注册一个回调函数，该函数会在fd有事件时调用，在该函数中将fd加入到epoll的就绪队列中。 
 C．检查fd当前是否已经有期望的事件产生。如果有，将其加入到epoll的就绪队列中，唤醒epoll_wait。 

 2． 修改事件 op = EPOLL_CTL_MOD 
 修改事件只是将新的事件替换旧的事件，然后检查fd是否有期望的事件。如果有，将其加入到epoll的就绪队列中，唤醒epoll_wait。 

 3． 删除句柄 op = EPOLL_CTL_DEL 
 将fd从hash（rbtree）中清除。 
 1.3 long sys_epoll_wait(int epfd, struct epoll_event events, int maxevents,int timeout) 
 如果epoll的就绪队列为空，并且timeout非0，挂起当前进程，引起CPU调度。 
 如果epoll的就绪队列不空，遍历就绪队列。对队列中的每一个节点，获取该文件已触发的事件，判断其中是否有我们期待的事件，如果有，将其对应的epoll_event结构copy到用户events。 

 revents = epi->file->f_op->poll(epi->file, NULL); 
 epi->revents = revents & epi->event.events; 
 if (epi->revents) { 
 …… 
 copy_to_user; 
 …… 
 } 
 需要注意的是，在LT模式下，把符合条件的事件copy到用户空间后，还会把对应的文件重新挂接到就绪队列。所以在LT模式下，如果一次epoll_wait某个socket没有read/write完所有数据，下次epoll_wait还会返回该socket句柄。 
 四、 使用epoll的注意事项 
 1. ET模式比LT模式高效，但比较难控制。 
 2. 如果某个句柄期待的事件不变，不需要EPOLL_CTL_MOD，但每次读写后将该句柄modify一次有助于提高稳定性，特别在ET模式。 
 3. socket关闭后最好将该句柄从epoll中delete（EPOLL_CTL_DEL），虽然epoll自身有处理，但会使epoll的hash的节点数增多，影响搜索hash的速度。 
  
  
 修改 删除 举报 引用 回复   
  
  加为好友 
 发送私信 
 在线聊天
  aSpace 
 一个空格 
 等级:
  发表于：2008-07-02 20:52:123楼 得分:0 
 Q：网络服务器的瓶颈在哪？ 
 A：IO效率。 

 在大家苦苦的为在线人数的增长而导致的系统资源吃紧上的问题正在发愁的时候，Linux 2.6内核中提供的System Epoll为我们提供了一套完美的解决方案。传统的select以及poll的效率会因为在线人数的线形递增而导致呈二次乃至三次方的下降，这些直接导致了网络服务器可以支持的人数有了个比较明显的限制。 

 自从Linux提供了/dev/epoll的设备以及后来2.6内核中对/dev/epoll设备的访问的封装（System Epoll）之后，这种现象得到了大大的缓解，如果说几个月前，大家还对epoll不熟悉，那么现在来说的话，epoll的应用已经得到了大范围的普及。 

 那么究竟如何来使用epoll呢？其实非常简单。 
 通过在包含一个头文件#include 以及几个简单的API将可以大大的提高你的网络服务器的支持人数。 

 首先通过create_epoll(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这个函数操作成功之后，epoll_events里面将储存所有的读写事件。max_events是当前需要监听的所有socket句柄数。最后一个timeout是 epoll_wait的超时，为0的时候表示马上返回，为-1的时候表示一直等下去，直到有事件范围，为任意正整数的时候表示等这么长的时间，如果一直没有事件，则范围。一般如果网络主循环是单独的线程的话，可以用-1来等，这样可以保证一些效率，如果是和主逻辑在同一个线程的话，则可以用0来保证主循环的效率。 

 epoll_wait范围之后应该是一个循环，遍利所有的事件： 

 C/C++ codefor(n = 0; n < nfds; ++n) {
                if(events[n].data.fd == listener) { //如果是主socket的事件的话，则表示有新连接进入了，进行新连接的处理。
                    client = accept(listener, (struct sockaddr ) &local,
                                    &addrlen);
                    if(client < 0){
                        perror("accept");
                        continue;
                    }
                    setnonblocking(client); // 将新连接置于非阻塞模式
                    ev.events = EPOLLIN | EPOLLET; // 并且将新连接也加入EPOLL的监听队列。
 注意，这里的参数EPOLLIN | EPOLLET并没有设置对写socket的监听，如果有写操作的话，这个时候epoll是不会返回事件的，如果要对写操作也监听的话，应该是EPOLLIN | EPOLLOUT | EPOLLET
                    ev.data.fd = client;
                    if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, client, &ev) < 0) {
 //  设置好event之后，将这个新的event通过epoll_ctl加入到epoll的监听队列里面，这里用EPOLL_CTL_ADD来加一个新的 epoll事件，通过EPOLL_CTL_DEL来减少一个epoll事件，通过EPOLL_CTL_MOD来改变一个事件的监听方式。
                        fprintf(stderr, "epoll set insertion error: fd=d0,
                                client);
                        return -1;
                    }
                }
                else // 如果不是主socket的事件的话，则代表是一个用户socket的事件，则来处理这个用户socket的事情，比如说read(fd,xxx)之类的，或者一些其他的处理。
                    do_use_fd(events[n].data.fd);
 }

 

 对，epoll的操作就这么简单，总共不过4个API：epoll_create, epoll_ctl, epoll_wait和close。