手把手教你玩转SOCKET模型之重叠I/O篇(上)

手把手教你玩转SOCKET 模型之重叠I/O 篇

 

“ 身为一个初学者，时常能体味到初学者入门的艰辛，所以总是想抽空作点什么来尽我所能的帮助那些需要帮助的人。我也希望大家能把自己的所学和他人一起分享，不要去鄙视别人索取时的贪婪，因为最应该被鄙视的是不肯付出时的吝啬。”

                                                                                                                          ----- 题记   By PiggyXP( 小猪 )

前    言

  其实我首先应该道歉，因为 7 月份的时候曾信誓旦旦的说要写一套关于 SOCKET 所有模型的入门文章以及配套代码，不过没想到后天竟然被美女所迷出去度假了，刚刚回来不久。。。。。。 -_-b 其实那些模型的配套代码我已经基本写完了，只是没写配套文字，不过我想还是先从稍微难一点的模型写起吧，因为其他模型的入门毕竟要简单一些。

不过由于也是初学者，疏漏之处还望不吝指正。

本文凝聚着笔者心血，如要转载，请指明原作者及出处，谢谢！ ^_^

OK, Let’s go !  Have fun ！ ! q^_^p

 

本文配套的示例源码下载地址

(VC.net 2003 编写的多客户端 MFC 代码，配有详尽注释，只是简单的显示一下客户端发来的字符，稍加改进就是个聊天室了 ) ：

http://www.haha567.com/PiggyXP/OverlappedModel.rar

(unix 系统，千万注意链接大小写 )

非常感谢网络版的 limin 兄弟为我无偿提供的空间，以及在我学习过程中给我的大力帮助与支持，真的非常感谢他，感激涕零啊 ~~~~~T_T

也欢迎大家光临他的 Blog 一起讨论网络技术

http://blog.haha567.com/

 

( 本文假设你已经具备用 SOCKET 简单模型编程的能力，如果对 SOCKET 一无所知请关注本系列其他文章 )

 

目录：

1． 重叠模型的优点

2． 重叠模型的基本原理

3． 关于重叠模型的基础知识

4． 重叠模型的实现步骤

5． 多客户端情况的注意事项

 

 

一．             重叠模型的优点

1.      可以运行在支持 Winsock2 的所有 Windows 平台 , 而不像完成端口只是支持 NT 系统。

2.      比起阻塞、 select 、 WSAAsyncSelect 以及 WSAEventSelect 等模型，重叠 I/O(Overlapped I/O) 模型使应用程序能达到更佳的系统性能。

         因为它和这 4 种模型不同的是，使用重叠模型的应用程序通知缓冲区收发系统直接使用数据，也就是说，如果应用程序投递了一个 10KB 大小的缓冲区来接收数据，且数据已经到达套接字，则该数据将直接被拷贝到投递的缓冲区。

而这 4 种模型种，数据到达并拷贝到单套接字接收缓冲区中，此时应用程序会被告知可以读入的容量。当应用程序调用接收函数之后，数据才从单套接字缓冲区拷贝到应用程序的缓冲区，差别就体现出来了。

3.      从《 windows 网络编程》中提供的试验结果中可以看到，在使用了 P4 1.7G Xero 处理器 (CPU 很强啊 ) 以及 768MB 的回应服务器中，最大可以处理 4 万多个 SOCKET 连接，在处理 1 万 2 千个连接的时候 CPU 占用率才 40% 左右 ―― 非常好的性能，已经直逼完成端口了 ^_^

        

 

二．             重叠模型的基本原理

      说了这么多的好处，你一定也跃跃欲试了吧，不过我们还是要先提一下重叠模型的基本原理。

      概括一点说，重叠模型是让应用程序使用重叠数据结构 (WSAOVERLAPPED) ，一次投递一个或多个 Winsock I/O 请求。针对这些提交的请求，在它们完成之后，应用程序会收到通知，于是就可以通过自己另外的代码来处理这些数据了。

      需要注意的是，有两个方法可以用来管理重叠 IO 请求的完成情况（就是说接到重叠操作完成的通知）：

1.      事件对象通知 (event object notification)

2.      完成例程 (completion routines) , 注意，这里并不是完成端口

而 本文只是讲述如何来使用事件通知的的方法实现重叠 IO 模型， 完成例程的方法准备放到下一篇讲 ：） ( 内容太多了，一篇写不完啊 ) ，如没有特殊说明，本文的重叠模型默认就是指的基于事件通知的重叠模型。

既然是基于事件通知，就要求将 Windows 事件对象与 WSAOVERLAPPED 结构关联在一起（ WSAOVERLAPPED 结构中专门有对应的参数），通俗一点讲，就是。。。。对了，忘了说了，既然要使用重叠结构，我们常用的 send, sendto, recv, recvfrom 也都要被 WSASend, WSASendto, WSARecv, WSARecvFrom 替换掉了， 它们的用法我后面会讲到，这里只需要注意一点，它们的参数中都有一个 Overlapped 参数，我们可以假设是把我们的 WSARecv 这样的操作操作“绑定”到这个重叠结构上，提交一个请求，其他的事情就交给重叠结构去操心，而其中重叠结构又要与 Windows 的事件对象“绑定”在一起，这样我们调用完 WSARecv 以后就可以“坐享其成”，等到重叠操作完成以后，自然会有与之对应的事件来通知我们操作完成，然后我们就可以来根据重叠操作的结果取得我们想要德数据了。

      也许说了半天你还是不大明白，那就继续往后面看吧。。。。。。。 -_-b ，语言表达能力有限啊 ~~~

 

 

三．             关于重叠模型的基础知识

      下面来介绍并举例说明一下编写重叠模型的程序中将会使用到的几个关键函数。

1.      WSAOVERLAPPED 结构

这个结构自然是重叠模型里的核心，它是这么定义的

typedef struct _WSAOVERLAPPED

 {



  
DWORD

 
Internal;





 
 DWORD

 
InternalHigh;





  
DWORD

 Offset;





  
DWORD

 
OffsetHigh;





  
WSAEVENT

 hEvent;

      
// 
唯一需要关注的参数，用来关联
WSAEvent
对象

       } WSAOVERLAPPED, *LPWSAOVERLAPPED;

我们需要把
WSARecv
等操作投递到一个重叠结构上，

而我们又需要一个与重叠结构“绑定”在一起的事件对象来通知我们操作的完成，看到了和
hEvent
参数，

不用我说你们也该知道如何来来把事件对象绑定到重叠结构上吧？大致如下：

WSAEVENT event;
                   // 
定义事件

WSAOVERLAPPED 
AcceptOverlapped ; 
// 
定义重叠结构

event = WSACreateEvent();         
// 
建立一个事件对象句柄

ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED)); 
// 
初始化重叠结构

AcceptOverlapped.hEvent = event;    
// Done !
！

2.      WSARecv 系列函数

在重叠模型中，接收数据就要靠它了，它的参数也比 recv 要多，因为要用刀重叠结构嘛，它是这样定义的：

            

int

 WSARecv(

                        SOCKET
 s



,                      

// 
当然是投递这个操作的套接字

                        LPWSABUF
 lpBuffers



,          

// 
接收缓冲区，与
Recv
函数不同

// 
这里需要一个由
WSABUF
结构构成的数组

         DWORD
 dwBufferCount



,        

// 
数组中
WSABUF
结构的数量

            LPDWORD
 lpNumberOfBytesRecvd



,  

// 
如果接收操作立即完成，这里会返回函数调用

// 
所接收到的字节数

          LPDWORD
 lpFlags



,             

// 
说来话长了，我们这里设置为
0 
即可

          LPWSAOVERLAPPED
 lpOverlapped



, 

 

// 
“绑定”的重叠结构

          LPWSAOVERLAPPED_COMPLETION_ROUTINE
 lpCompletionRoutine

                              

 
// 
完成例程中将会用到的参数，我们这里设置为 NULL

                );

返回值：

WSA_IO_PENDING
 
：
 
最常见的返回值，这是说明我们的
WSARecv
操作成功了，但是

                    I/O
操作还没有完成，所以我们就需要绑定一个事件来通知我们操作何时完成

举个例子：
(
变量的定义顺序和上面的说明的顺序是对应的，下同
)

SOCKET s;

WSABUF DataBuf;           
// 
定义
WSABUF
结构的
缓冲区

// 
初始化一下
DataBuf

#define DATA_BUFSIZE 5096

char buffer[DATA_BUFSIZE];

ZeroMemory(buffer, DATA_BUFSIZE);

DataBuf.len = DATA_BUFSIZE;

DataBuf.buf = buffer;

DWORD dwBufferCount = 1, dwRecvBytes = 0, Flags = 0;

// 
建立需要的重叠结构

WSAOVERLAPPED AcceptOverlapped ;
// 
如果要处理多个操作，这里当然需要一个

// WSAOVERLAPPED
数组

WSAEVENT event;     
// 
如果要多个事件，这里当然也需要一个
WSAEVENT
数组

                           // 
需要注意的是可能一个
SOCKET
同时会有一个以上的重叠请求，

//  
也就会对应一个以上的
WSAEVENT

Event = WSACreateEvent();

ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED));

AcceptOverlapped.hEvent = event;    
 // 
关键的一步，把事件句柄“绑定”到重叠结构上

// 
作了这么多工作，终于可以使用
WSARecv
来把我们的请求投递到重叠结构上了，呼。。。。

WSARecv(s, &DataBuf, dwBufferCount, &dwRecvBytes, 

&Flags, &AcceptOverlapped, NULL);

其他的函数我这里就不一一介绍了，因为我们毕竟还有MSDN
这么个好帮手，而且在讲后面的完成例程和完成端口的时候我还会讲到一些 ^_^

3.      WSAWaitForMultipleEvents 函数

熟悉 WSAEventSelect 模型的朋友对这个函数肯定不会陌生，不对，其实大家都不应该陌生，这个函数与线程中常用的 WaitForMultipleObjects 函数有些地方还是比较像的，因为都是在等待某个事件的触发嘛。

因为我们需要事件来通知我们重叠操作的完成，所以自然需要这个等待事件的函数与之配套。

                        DWORD

 WSAWaitForMultipleEvents(

                                  DWORD
 cEvents



,

                        // 
等候事件的总数量

                                  const WSAEVENT*
 lphEvents



,           

// 
事件数组的指针

                                  BOOL
 fWaitAll



,          

// 
这个要多说两句：

                                                                  // 
如果设置为
 TRUE
，则事件数组中所有事件被传信的时候函数才会返回

                                                                  // FALSE
则任何一个事件被传信函数都要返回

                                                                  // 
我们这里肯定是要设置为
FALSE
的

                                  DWORD
 dwTimeout



,    

// 
超时时间，如果超时，函数会返回
 WSA_WAIT_TIMEOUT

                               // 
如果设置为
0
，函数会立即返回

                            // 
如果设置为
 WSA_INFINITE
只有在某一个事件被传信后才会返回

                            // 
在这里不建议设置为
WSA_INFINITE
，因为。。。后面再讲吧
..-_-b

                                  BOOL
 fAlertable


       

// 
在完成例程中会用到这个参数，这里我们先设置为
FALSE

                                );

返回值：

    WSA_WAIT_TIMEOUT
 
：最常见的返回值，我们需要做的就是继续
Wait

    WSA_WAIT_FAILED 
：
 
出现了错误，请检查
cEvents



和
lphEvents



两个参数是否有效

如果事件数组中有某一个事件被传信了，函数会返回这个事件的索引值，

但是这个索引值需要减去预定义值
 WSA_WAIT_EVENT_0
才是这个事件在事件数组中的位置。

具体的例子就先不在这里举了，后面还会讲到

注意：
WSAWaitForMultipleEvents
函数只能支持由
WSA_MAXIMUM_WAIT_EVENTS
对象定义的一个最大值，是
 
64
，就是说
WSAWaitForMultipleEvents
只能等待
64
个事件，如果想同时等待多于
64
个事件，就要
 
创建额外的工作者线程，就不得不去管理一个线程池，这一点就不如下一篇要讲到的完成例程模型了。

 

4.      WSAGetOverlappedResult 函数

既然我们可以通过 WSAWaitForMultipleEvents 函数来得到重叠操作完成的通知，那么我们自然也需要一个函数来查询一下重叠操作的结果，定义如下

            BOOL
 WSAGetOverlappedResult(

                          SOCKET 
s




,                   
// SOCKET
，不用说了

                          LPWSAOVERLAPPED 
lpOverlapped




,  
// 
这里是我们想要查询结果的那个重叠结构的指针

                          LPDWORD 
lpcbTransfer




,     
// 
本次重叠操作的实际接收
(
或发送
)
的字节数

                          BOOL
 
fWait




,                
// 
设置为
TRUE
，除非重叠操作完成，否则函数不会返回

                                                              // 
设置
FALSE
，而且操作仍处于挂起状态，那么函数就会返回
FALSE

                                                              // 
错误为
WSA_IO_INCOMPLETE

                                                              // 
不过因为我们是等待事件传信来通知我们操作完成，所以我们这里设

                // 
置成什么都没有作用
…..-_-b  
别仍鸡蛋啊，我也想说得清楚一些
…

                          LPDWORD
 
lpdwFlags


       

// 
指向
DWORD
的指针，负责接收结果标志

                        );

这个函数没什么难的，这里我们也不需要去关注它的返回值，直接把参数填好调用就可以了，这里就先不举例了

唯一需要注意一下的就是如果
WSAGetOverlappedResult
完成以后，第三个参数返回是
 0 
，则说明通信对方已经关闭连接，我们这边的
SOCKET, Event
之类的也就可以关闭了。