三: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.dwNumberOfProcessors*2+2 do
begin
  AThread := TRecvSendThread.Create( false );
  AThread.CompletPort := FCompletPort;//告诉这个线程,你要去这个IOCP去访问数据
end;

   就这么简单,我们要做的就是建立一个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是否完成了我们投递的读写操作,如果完成了则再投递一个新的读写请求