两个要解决的问题

现代网络中，IPv4, IPv6 共存的情况日益增加，而这两种协议的地址格式，地址解析的 API 各不同，程序员必须面对如下两个问题并且合理地解决这些问题。

1. 怎么准确识别用户输入的地址或者域名是属于 IPv4 网络还是 IPv6 网络？ 
   
   
2. 怎么屏蔽网络连接细节，提供给用户一个统一的接口？ 
   
   

IPv4 与 IPv6 对比

目前我们使用的第二代互联网 IPv4 技术，它的最大问题是网络地址资源有限，IPv6 是“Internet Protocol Version 6”的缩写，它是 IETF 设计的用于替代现行版本 IP 协议 -IPv4- 的下一代 IP 协议。与 IPV4 相比，IPv6 具有更大的地址空间。IPv4 中规定 IP 地址长度为 32 位；而 IPv6 中 IP 地址的长度为 128 位。

在 IPv4 网络下，网络编程主要依靠的是 socket 连接。在客户端，其基本步骤如下，创建一个 socket，使用 socket 连接服务器，最后通过 TCP 或者 UDP 协议进行数据读写。如果把这套方法移植到 IPv6 网络下，就需要在原来的基础上引入新的协议族、新的数据结构以及新的地址域名转换函数等。具体的一些差异如 图 1所示：

在这里要稍微介绍下 getaddrinfo（）函数，它提供独立于协议的名称解析。函数的前两个参数分别是节点名和服务名。节点名可以是主机名，也可以是地址串 (IPv4 的点分十进制数表示或 IPv6 的十六进制数字串 )。服务名可以是十进制的端口号，也可以是已定义的服务名称，如 ftp、http 等。函数的第三个参数 hints 是 addrinfo 结构的指针，由调用者填写关于它所想返回的信息类型的线索。函数的返回值是一个指向 addrinfo 结构的链表指针 res。详见 图 2。

getaddrinfo 函数之前通常需要对以下 6 个参数进行以下设置：nodename、servname、hints 的 ai_flags、ai_family、ai_socktype、ai_protocol。在 6 项参数中，对函数影响最大的是 nodename，sername 和 hints.ai_flag。而 ai_family 只是有地址为 v4 地址或 v6 地址的区别。而 ai_protocol 一般是为 0 不作改动。其中 ai_flags、ai_family、ai_socktype。说明如 图 3所示：

getaddrinfo 函数在 IPv6 和 IPv4 网络下都能实现独立于协议的名称解析，而且它返回的指向 addrinfo 结构的链表中会存放所有由输入参数 nodename 解析出的所有对应的 IP 信息，包括 IP 地址，协议族信息等。所以只要对 const struct addrinfo* hints 进行一些配置，就可以利用这个函数来识别连接目标的网络协议属性，进而根据其网络协议族而进行准确的连接操作。这样就解决了我们提出的第一个问题。具体的函数实现如下 清单 1所示：

				  BaseSocket* BaseSocket::CreateSmartSocket(char* ipaddr)   { 		     struct addrinfo *answer, hint, *curr;      bzero(&hint, sizeof(hint));      hint.ai_family = AF_UNSPEC;      hint.ai_socktype = SOCK_STREAM;      char ipstr2[128];      struct sockaddr_in  *sockaddr_ipv4;      struct sockaddr_in6 *sockaddr_ipv6;      	         int ret = getaddrinfo(ipaddr, NULL,&hint, &answer);      if (ret != 0) {          return NULL;      }      DeleteSmartSocket();       for (curr = answer; curr != NULL; curr = curr->ai_next) {          switch (curr->ai_family){              case AF_UNSPEC:                  //do something here                  break;              case AF_INET:                  sockaddr_ipv4 = reinterpret_cast<struct sockaddr_in *>( curr->ai_addr);                  inet_ntop(AF_INET, &sockaddr_ipv4->sin_addr, ipstr2,sizeof(ipstr2));                  smartSocketmap[typeIPv4]=new  SocketV4(ipstr2);                  break;              case AF_INET6:                  sockaddr_ipv6 = reinterpret_cast<struct sockaddr_in6 *>( curr->ai_addr);                  inet_ntop(AF_INET6, <sockaddr_ipv6->sin6_addr, ipstr2,sizeof(ipstr2));                  smartSocketmap[typeIPv6]=new  SocketV6(ipstr2);                  break;          }      } 	         freeaddrinfo(answer);      if(!smartSocketmap.empty())      {          smartSocket=new BaseSocket();      }       return smartSocket;   }   

回页首

代码结构设计

对于用户来说，他们只想实现网络连接，而并不希望了解太多网络连接上冗繁的细节。如何屏蔽 IPv4 和 IPv6 网络的差异性，让用户使用统一的函数接口来完成操作，就成为我们的第二个课题。 程序中申明了一个基类叫 BaseSocket，继承于它的两个子类 SocketV4 和 SocketV6 分别负责有关 IPv4、IPv6 网络环境下的各种操作。详见 图 4。

在设计 BaseSocket 类的时候，并没有把它作为一个单纯的基类来使用，而是把它设计成了一个 SocketV4 和 SocketV6 的代理类。我们都知道，C++ 支持向上类型转换（取一个对象的地址，并将其作为基类的地址使用），结合虚函数能够实现多态性，我们就在这里使用一个基类的指针使其指向不同的子类实例，并把这些指针放到一个容器内。这样设计的初衷是希望外部使用者只使用类的公共接口，享受类的服务，而无需关注类的内部实现细节。具体来说，就是在 IPv4、IPv6 同时存在的网络环境下，用户只需要享用 BaseSocket 类提供出的公共服务，而无需关注具体网络环境下网络操作的差异性。 为了达到上述的目的，BaseSocket 类的设计主要做了了以下几点处理：

1. 把构造和析构函数隐藏起来（单件模式）
   

   在 BaseSocket 的函数申明中，通常作为类公共成员的构造函数和析构函数被塑造成了 protected 成员函数。而开放给用户创建真正操作对象的函数却是 CreateSmartSocket()。CreateSmartSocket() 函数会动态地根据网络环境创建合适的子类 SocketV4 或者 SocketV6，使用的方法就是调用上文中提到的 getaddrinfo() 函数。生成的子类对象都存储在静态 smartSocketmap 中。这样设计的原因是在于如果不这样做，用户就必须根据不同的网络来创建属于 IPv4 或者 IPv6 网络的 socket 子类，然后分别调用他们的成员函数，这样繁琐又不利于用户代码的维护和扩展。smartSocketmap 以这样的设计为用户构建对象创作的一个统一的接口，在不同网络下，只需要维护一套统一的代码，而无需为不同网络下的实现细节而费神。

   
   
2. 向用户提供代理对象
   

   在 BaseSocket 类中申明了两个 BaseSocket 类型的指针，一个是 smartSocket，另外一个是 m_cursocket。BaseSocket* smartSocket 是一个静态的全局代理指针，用户只通过它来进行网络操作。在客户程序中，只存在一份由 CreateSmartSocket() 函数创建的 smartSocket 的副本，这是因为在每次需要网络连接时网络环境相应是固定的，不会由 v4 网络突然转变成 v6 网络，一个副本在运行时已经满足使用需求。CreateSmartSocket() 函数会先去侦测存储空间堆上是否已经存在 smartSocket 指针，存在的话就会调用 DeleteSmartSocket() 删除之前创建的副本，然后再创建一个新的 smartSocket 指针，提供给用户使用。而 m_cursocket 是指向真正操作对象（子类）的指针。值得注意的是，m_cursocket 指针是隐藏在 BaseSocket 类中的，而 smartSocket 正是 BaseSocket 类为 m_cursocket 封装的一层代理指针。用户所知的仅仅是调用了 smartSocket 的某个成员函数，而实际上，程序通过把 m_cursocket 定位到 map smartSocketmap 中的某一项，获得了真正的 SocketV4 或者 SocketV6 对象。

   
   
   图 5. 对象结构图
    
   
   
   
   图 6. 获取 smartSocket 对象流程图
    
   
   

   图 5和 图 6就展示了程序如何根据用户输入的地址信息判断网络类型，继而创建 smartSocket 对象的过程。

   
   
3. 使用虚函数（实现多态性）
   

   在基类中，主要操作的函数都被申明为虚函数。如果编译器发现一个类中有被声明为 virtual 的函数，就会为其生成一个虚函数表，也就是 VTABLE。VTABLE 实际上是一个函数指针的数组，每个虚函数占用这个数组的一个位置。派生类有自己的 VTABLE，但是派生类的 VTABLE 与基类的 VTABLE 有相同的函数排列顺序，同名的虚函数被放在两个数组的相同位置上。在创建类实例的时候，编译器还会在每个实例的内存布局中增加一个 vptr 字段，该字段指向本类的 VTABLE。C++ 对于虚函数的调用采用晚捆绑，从而能够实现多态性。 在程序中，m_cursocket 虽然是一个基类指针，但它指向的却是一个子类对象地址。由于这样的转换是子类向上转换，所以是安全的。指向正确的子类对象后，如果需要调用成员函数，就能通过本实例中的 vptr 指针指向本类的 VTABLE，由此获得正确的子类成员函数的地址来进行操作。

   
   
   图 7. 利用 smartSocket 对象进行网络连接流程图
    
   
   
   

图 7描述了 m_cursocket 如何进行类型转换，获得准确的子类对象，并且调用子类 Connect 函数的过程。

综上所述，通过以上三点，就可以降低用户程序和网络操作 Socket 部分的耦合性。让用户容易地实现他们所需要的网络连接，而不必要太关注网络环境的细节。同样，因为耦合性降低，有关 Socket 代码部分的更新和维护也相对方便，不会牵一发而动全身。

回页首

OpenSSL 之 https 应用案例

下面我们展示一个网络连接实例，在这个实例中，我们会使用到 SSL 连接。众所周知，有些 server 或者网站会启用 SSL 进行安全连接，那么对于这一类的网络连接就不是简单的使用 socket 可以解决的，我们必须借用 OpenSSL 来帮助我们实现。通常我们的底层数据是用 OpenSSL 的 BIO 对象来处理的，借助 BIO_new_ssl(), BIO_new_accept() 等函数轻松实现 IPv4 环境下的网络安全连接。然而这些方法在 IPv6 的环境下却没有实现很好的支持。为此，我们需要另辟蹊径来达成我们的目标。经过一段时间对 OpenSSL 文档的研究，我们发现以下方法既可以实现我们安全连接的目的，又可以同时支持 IPv4 和 IPv6 两种网络环境，具有比较好的可扩展性。这个方法十分简单，那就是手工创建一个 socket，该 socket 连接了一个 IPv6 或者 IPv4 地址，然后将 socket 绑定到某个 SSL 对象上就可以实现 SSL 的连接了。

1. 网络连接
   

   这个部分首先调用 BaseSocket::GetSmartSocket（）创建了一个 HTTPsSocket，HTTPsSocket 得到的就是代理指针 smartSocket 的地址，然后试图调用 HTTPsSocket->sockConnect() 连接 SSL 端口。从调用过程可见用户根本不用关心他现在所处的网络是 IPv4 还是 IPv6 网络，只要调用统一的函数接口就可以了。如 清单 2所示。

   
   
   清单 2. smartSocket 建立网络连接
   

   /* Create a HTTPsSocket */ if((HTTPsSocket=BaseSocket::GetSmartSocket())==NULL) HTTPsSocket =BaseSocket::CreateSmartSocket(const_cast<char *>(SPName.c_str())); if(HTTPsSocket==NULL) { return -1; } /* Connect the HTTPsSocket to SSLport */ if (HTTPsSocket->isConnected()) { HTTPsSocket->disconnect(); } if(HTTPsSocket->sockConnect(SSLport)) { return SOCKETERR; } // END OF CONNECT TO THE SSLport

   
   
   
2. 初始化 SSL
   

   这里是为了实现安全连接，对 openSSL 对象进行创建和初始化配置。如下 清单 3所示。

   
   
   清单 3. 初始化 OpenSSL
   

   /* Lets get nice error messages */ SSL_load_error_strings(); /* Setup all the global SSL stuff */ SSL_library_init(); ctx=SSL_CTX_new(SSLv23_client_method()); if(ctx==NULL) { return -1; } /* Lets make a SSL structure */ if (!(ssl = SSL_new(ctx))) { return -1; }

   
   
   
3. 绑定 smartSocket 到 SSL
   

   通过把 smartSocket 的系统 fd 绑定到生成的 ssl 对象上，就可以在 HTTPsSocket 上加载 openSSL 协议了。最后使用 SSL_connect() 函数进行连接。如 清单 4所示。

   
   
   清单 4. 绑定 smartSocket 到 SSL
   

   /* Lets bind socket fd to the SSL structure */ int fd=HTTPsSocket->getSocketFD(); SSL_set_fd(ssl, fd); /* Lets use a SSL connect */ if (SSL_connect (ssl) <= 0 ) { return -1; }

   
   
   
4. 接收数据
   

   利用先建立起的 smartSocket 连接进行数据接收。如 清单 5所示。

   
   
   清单 5. 接收数据
   

   int each = 0; /*If it is openSSL enabled connection, then use SSL_read to get the message, otherwise use default HTTPSocket->sockRecv() function*/ if(SSLenabled) { each = SSL_read(ssl, buff, len ); } else { each = HTTPSocket->sockRecv((unsigned char *)buff, len, 0 ); } return each;

   
   
   
5. 发送数据
   

   利用先建立起的 smartSocket 连接进行数据发送。如 清单 6所示。

   
   
   清单 6. 发送数据
   

   /*If it is openSSL enabled connection, then use SSL_write to send the message, otherwise use default HTTPSocket->sockSend() function*/ int trans = 0, each = 0; if(SSLenabled) { while (trans < len) { if((each = SSL_write(ssl, buf + trans, len - trans)) == 0) { return SOCKETERR ; } trans += each ; } } else { while (trans < len) { if((each=HTTPSocket->sockSend((unsigned char *)buf+trans,len-trans,0))==0) { return SOCKETERR ; } trans += each ; } } return trans;

   
   
   

回页首

小结

本文介绍了一种屏蔽 socket 网络连接细节的代码设计，该方法可以很好地适应 IPv4 和 IPv6 的网络环境，而且它提供给用户一个统一的接口，把用户从 v4 或者 v6 网络的连接细节中解放出來。

参考资料

学习

• IPv6 Guide for Windows Sockets Applications
  
  
• Using the Checkv4.exe Utility
  
  
• Appendix A: IPv4-only Source Code
  
  
• Appendix B: IP-version Agnostic Source Code
  
  
• 在 developerWorks Linux 专区 寻找为 Linux 开发人员（包括 Linux 新手入门）准备的更多参考资料，查阅我们 最受欢迎的文章和教程。 
  
  
• 在 developerWorks 上查阅所有 Linux 技巧 和 Linux 教程。 
  
  
• 随时关注 developerWorks 技术活动和网络广播。 
  
  

获得产品和技术

• 下载 IBM 软件试用版，体验强大的 DB2®，Lotus®，Rational®，Tivoli®和 WebSphere®软件。
  
  

讨论

• 参与论坛讨论。
  
  
• 查看 developerWorks 博客的最新信息。
  
  
• 欢迎加入 My developerWorks 中文社区。
  
  

作者简介

2.

　　NAT是为了节省IP地址而设计的，但它隐藏了内网机器的地址，“意外”起到了安全的作用。对外不可见，不透明的内部网络也与互联网的“公平” 应用，“相互共享”的思想所不容，尤其是P2P网络中“相互服务”的宗旨，所以穿越NAT，让众多内部网络的机器也参与到P2P网络中的大集体中来，一直 是P2P开发者的所希望的。穿越NAT需要借助外部的支持，说白了就是“内外勾结”，骗过NAT。很多P2P网络成功地实现了这一目标，但还是有一些“遗 憾”---并非所有的情况下都可以。由于客户端是主动登录P2P网络才可穿越，所以P2P的方式也没有违背企业的内部管理原则，毕竟“自由世界”的加入都 是自觉自愿的。

　　NAT原理：

　　NAT(Network Address Translation)网络地址转换/网络地址翻译。

　　工作原理：NAT主要的通过对数据包头的地址替换来完成内网计算机访问外网服务的。当内部机器要访问外部网络时，NAT设备把内部的IP1与端 口号1(网络层地址与传输层地址)，转换成NAT的外部IP2与新的端口号2，再送给外部网络，数据返回时，再把目的为IP2:端口2的数据包替换为 IP1:端口1，送给内网机器。若通讯协议的内容中有IP地址的传递，如FTP协议，NAT在翻译时还要注意数据包内涉及协议地址交互的地方也要替换，否 则协议就会出现地址混乱。在NAT设备中维护了这个要替换地址的映射表，并根据内部计算机的通讯需求维护该表。外部网络来数据包能否进入NAT，主要是看 是否已经有可映射的表项，若没有就会丢弃。

　　NAT的外部公网地址可以是一个IP，也可以是一个网段，形成地址池。NAT还可以把某个外网地址直接影射给内网的某个服务器，让外网的用户可以直接访问到这台服务器。NAT的工作的隐藏内网的机器，但允许内网主动打开到外网的通讯“通道”，也就是建立映射表项。

　　NAT给P2P带来的问题是：NAT只允许单方面发起连接，通讯的双方不是平等的，P2P网络的基础有了问题，具体的表现为：

　　内网主机IP是私有的，外部主机看不到，也无法主动发起连接

　　即使知道了内网IP，但NAT会丢弃没有在影射表的数据包

　　内网主机可以作为客户端访问外网，但不能作为服务器提供服务

　　当两个主机都位于各自的NAT之后，要实现P2P的连接，就不仅是谁主动的问题，而是如何解决在两个NAT上同时有对方映射表项的问题。

STUN协议(IETF RFC 3489)：

　　STUN协议是一种通道协议，可以作为正式通讯前的通路建立，它采用的是用户终端干预的一种方法，可以解决应用协议内部传递IP地址给NAT带 来的麻烦。用户通过其他方法得到其地址对应在NAT出口上的对外地址，然后在报文负载中所描述的地址信息就直接填写NAT上对外地址，而不是内网的私有 IP，这样报文的内容在经过NAT时就按普通的NAT流程转换报文头部的IP地址即可，负载内的IP地址信息无需再修改。利用STUN的思路可以穿越 NAT。STUN协议是客户端/服务器协议，分两种请求方式：一是UDP发送的绑定请求(Binding Requests)，二是TCP发送的秘密请求(Shared Secret Requests)。绑定请求用于确定NAT分配的绑定地址。

　　STUN标准中，根据内部终端的地址(P:p)到NAT出口的公网地址(A:b)的影射方式，把NAT分为四种类型：

　　1. Full Cone：来自相同的内部地址的请求消息映射为相同的外部地址，与外部地址(目的地址)无关。映射关系为P:p↔A:b，任何外部主机可通过(A:b)发送到数据到(P:p)上。

　　2. Restricted Cone：来自相同的内部地址的请求消息映射为相同的外部地址，返回的数据只接受该内部节点曾发数据的那个目的计算机地址X。映射关系为P:p↔A:b↔X，只有来自X的数据包才可通过(A:b)发送到数据到(P:p)上。

　　3. Port Restricted Cone：来自相同的内部地址的请求消息映射为相同的外部地址，返回的数据只接受该内部节点曾发数据的那个目的地址X:x。映射关系为 P:p↔A:b↔X:x，只有来自X:x的数据包才可通过(A:b)发送到数据到(P:p)上。

　　4. Symmetric(对称) NAT：只有来自相同的内部地址(P:p)，并且发送到同一个地址(X:x) 的请求消息，才被映射为相同的外部地址(A:b)，返回的数据只接受该内部节点曾发数据的那个目的地址X:x。映射关系为P:p↔A:b↔X:x，当 (P:p)访问(Y:y)时，映射为P:p↔B:c↔Y:y。

　　P2P利用STUN穿越NAT：

　　位于NAT后面终端A与B要穿越NAT直接通讯，可以借助在公网上的第三者Server来帮助。

　　穿越NAT的情况分为为两种方式：

    1、一方在NAT之后，一方在公网上。这种情况相对简单，只要让NAT之后的终端先发起通讯，NAT就没有作用了，它可以从Server上取得另一个Peer的地址，主动连接，回来的数据包就可以方便地穿越NAT。

    2、双方都在NAT之后，连接的成功与否与两个NAT的类型有关。主要的思路的先通过终端与Server的连接，获得两个终端在NAT外部的地址(IP与 端口号)，再由终端向对方的外部地址发邀请包，获取自己与对方通讯的外部地址，俗称为“打洞”。关键是获取了NAT外部映射的地址，就可以发包直接沟通， 建立连接。但当一方是对称型，另一方是Port Restricted或对称型时，无法有效获取外部地址，邀请包无法到达对方，也就无法穿越NAT。具体的分析可以根据两个NAT的类型分成若干情况分 析，这里给一般的穿越例子。

实例：UDP穿越NAT：

　　A登录Server，NAT A分配端口11000，Server得到A的地址为100.10.10.10:11000

　　B登录Server，NAT B分配端口22000，Server得到B的地址为200.20.20.20:22000

　　此时B会把直接来自A的包丢弃，所以要在NAT B上打一个方向为A的洞，那么A就可以向200.20.20.20:22000发送数据了

　　打洞的指令来自Server。B向A的地址100.10.10.10:11000发一个UDP报文，被NAT A丢弃，但在NAT B上建立映射记录，NAT B不在丢弃来自A的报文。

　　Server通知A可以通讯，A发起数据UDP包给B，NAT B放行，B收到A的包，双方开始通讯

　　注：若是对称NAT，当B向A打洞的端口要重新分配(NAT A不会再分配11000端口)，B无法获取这个端口，所以不适用本方法。

　　实例：TCP穿越NAT：

　　A登录Server，NAT A分配端口11000，Server得到A的地址为100.10.10.10:11000

　　B登录Server，NAT B分配端口22000，Server得到B的地址为200.20.20.20:22000

　　A向B发送TCP数据包SYN:192.168.10.11:1234=>200.20.20.20:22000，在NAT A上打洞

　　B向A发送TCP数据包SYN:192.168.20.22:1234=>100.10.10.10:11000，在NAT B上打洞

　　通道建立，A与B三次握手建立TCP连接

select,WSAAsyncSelect,WSAEventSelect,Overlapped,Completion。今天先讲解select。

1：select模型择模（选型）

先看一下下面的这句代码：

阻塞socket：

int iResult = recv(s, buffer,1024);

   这是用来接收数据的，在默认的阻塞模式下的套接字里，recv会阻塞在那里，直到套接字连接上有数据可读，把数据读到buffer里后recv函数才会返 回，不然就会一直阻塞在那里。

   在单线程的程序里出现这种情况会导致主线程（单线程程序里只有一个默认的主线程）被阻塞,这样整个程序被锁死在这里，如果永 远没数据发送过来，那么程序就会被永远锁死。这个问题可以用多线程解决，但是在有多个套接字连接的情况下，这不是一个好的选择，扩展性很差。

非阻塞 socket：

再看代码：
int iResult = ioctlsocket(s, FIOBIO, (unsigned long *)&ul);
iResult = recv(s, buffer,1024);

这一次recv的调用不管套接字连接上有没有数据可以接收都会马上返回。原因就在于我们用ioctlsocket把套接字设置为非阻塞模式了。不过你跟踪 一下就会发现，在没有数据的情况下，recv确实是马上返回了，但是也返回了一个错误：WSAEWOULDBLOCK，意思就是请求的操作没有成功完成。 看到这里很多人可能会说，那么就重复调用recv并检查返回值，直到成功为止，但是这样做效率很成问题，开销太大。

多线程来解决使用阻塞套接字存在的问题：

  多线程来解决阻塞套接字的方法是为阻塞套接字的IO操作创建单独的线程，阻塞的套接字IO操作放在单独的线程中，而不会因为套接字IO操作的阻塞造成整个主线程的阻塞，但是这样也会造成一定的问题：

1) 如果是多个套接字的场合通过多线程来解决主线程阻塞就会显得不合适了，server端创建一个监听socket来负责监听连接，而为accept函数

   为每个client端连接创建一个套接字，这样就会创建很多的套接字。如果是创建不同的套接字则应该创建多个线程，而每个线程的线程函数是

   不同的，这样就造成了所谓的扩展性很差。

2）如果不是每个连接创建一个套接字的话，duoxanch方法比较直观，程序非常简单而且可移植性好，但是不能利用平台相关的特性。例如，如 果连接数增多的时候（成千上万的连接），那么线程数成倍增长，操作 系统忙于频繁的线程间切换，而且大部分线程在其生命周期内都是处于非活动状态的，这大大浪费了系统的资源。所以，如果你已经知道你的代码只会运行在 Windows平台上，建议采用Winsock I/O模型。

微软提供了select函数来解决这个问题：

 int select(
int nfds,
fd_set FAR *readfds,
fd_set FAR *writefds,
fd_set FAR *exceptfds,
const struct timeval FAR *timeout
);

第一个参数不要管，会被系统忽略的。第二个参数是用来检查套接字可读性，也就说检查套接字上是否有数据可读，同样，第三个参数用来检查数据是否可以发出。最后一个是检查是否有带外数据可读取。

最后一个参数是用来设置select等待多久的，是个结构：
struct timeval {
long tv_sec; // seconds
long tv_usec; // and microseconds
};
如果将这个结构设置为(0,0)，那么select函数会马上返回。

 说了这么久，select的作用到底是什么？

他的作用就是：

1）防止在在阻塞模式的套接字里被锁死

2）避免在非阻塞套接字里重复检查WSAEWOULDBLOCK错误。

他的工作流程如下：

1：用FD_ZERO宏来初始化我们感兴趣的fd_set，也就是select函数的第二三四个参数。
2：用FD_SET宏来将套接字句柄分配给相应的fd_set。
3：调用select函数。
4：用FD_ISSET对套接字句柄进行检查，如果我们所关注的那个套接字句柄仍然在开始分配的那个fd_set里，那么说明马上可以进行相应的IO操 作。比如一个分配给select第一个参数的套接字句柄在select返回后仍然在select第一个参数的fd_set里，那么说明当前数据已经来了， 马上可以读取成功而不会被阻塞。

 1 #include "stdafx.h"
 2 #include <iostream>
 3 #include <winsock2.h>
 4 #include <windows.h>
 5 
 6 #define TRACE ATLTrace //必须要加上这个宏定义，否则在WIN32的控制台程序中是不能直接用的
 7 
 8 #define InternetAddr "127.0.0.1"
 9 #define iPort 5055
10 
11 #pragma comment(lib, "ws2_32.lib")
12 
13 int _tmain(int argc, _TCHAR* argv[])
14 {
15     WSADATA wsa;
16     WORD wVersionRequested;
17     int err;
18 
19    wVersionRequested = MAKEWORD( 2, 2 );
20     err = WSAStartup( wVersionRequested, &wsa);
21     if ( err != 0 ) {
22     //Tell the user that we could not find a usable 
23     //WinSock DLL.     
24     TRACE("你忘记添加WinSock DLL了\n");
25     WSACleanup();
26     return 1;
27      }
28 
29    // Create a SOCKET for listening for  incoming connection requests
30     SOCKET fdServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
31    
32     sockaddr_in server;
33 
34 　server.sin_family = AF_INET;
35 　server.sin_addr.s_addr = inet_addr(InternetAddr);
36 　server.sin_port = htons(iPort);
37  //Bind the socket.
38     int ret = bind(fdServer, (sockaddr*)&server, sizeof(server));
39     ret = listen(fdServer, 4);
40 
41     SOCKET AcceptSocket;
42     fd_set     fdread;
43 　timeval    tv;
44 　int nSize;
45    //其实也算是轮训，那么对阻塞socket用select和对使用非阻塞socket的优点在哪？
46   //可能的优点就是避免在非阻塞套接字里重复检查WSAEWOULDBLOCK错误。
47     while(1)
48  　{
49          　　　　　　　　
50          FD_ZERO(&fdread);//初始化fd_set
51          FD_SET(fdServer, &fdread);//分配套接字句柄到相应的fd_set
52                      　　　　　　　　
53         tv.tv_sec = 2;//这里我们打算让select等待两秒后返回，避免被锁死，也避免马上返回
54         tv.tv_usec = 0;
55                                          　　　　　　　　
56         select(0, &fdread, NULL, NULL, &tv);
57                                                  　　　　　　　　
58         nSize = sizeof(server);
59         //先判断fdServer是否还在fd_set内来判断是否可以读，这样就避免因为 accept在等待
60         //时造成的阻塞
61         if (FD_ISSET(fdServer, &fdread))
62             //如果套接字句柄还在fd_set里，说明客户端已经有connect的请求发过来了，
63             //马上可以accept成功
64         　{
65              AcceptSocket = accept(fdServer,( sockaddr*) &server, &nSize);
66              break;
67            }                                     　　　　　　　　
68         else
69         //还没有客户端的connect请求，我们可以去做别的事，避免像没有用select方式
70         //的阻塞套接字程序被锁死的情况，如果没用select,当程序运行到accept的时候客户
71         //端恰好没有connect请求，那么程序就会被锁死，做不了任何事情
72             {
73             //do something
74                MessageBox(NULL, "waiting", "recv", MB_ICONINFORMATION);
75         //别的事做完后，继续去检查是否有客户端连接请求
76             }
77  　　}
78 
79  　　char buffer[128];
80      　ZeroMemory(buffer, 128);
81 
82          ret = recv(AcceptSocket,buffer,128,0);//这里同样可以用select，用法和上面一样
83 
84          MessageBox(NULL, buffer, "recv", MB_ICONINFORMATION);
85 
86         closesocket(AcceptSocket);
87         WSACleanup();
88         return 0;
89 }
90 

select函数的返回值 ：

函数失败的返回值：调用失败返回SOCKET_ERROR,超时返回0。

WSAAsyncSelect是最简单的一种Winsock I/O模型（之所以说它简单是因为一个主线程就搞定了）。使用Raw Windows API写过窗口类应用程序的人应该都能看得懂。这里，我们需要做的仅仅是：
1.在WM_CREATE消息处理函数中，初始化Windows Socket library，创建监听套接字，绑定，监听，并且调用WSAAsyncSelect函数表示我们关心在监听套接字上发生的FD_ACCEPT事件；
2.自定义一个消息WM_SOCKET，一旦在我们所关心的套接字（监听套接字和客户端套接字）上发生了某个事件，系统发送消息(WM_SOCKET)给hWnd指向的窗体，而WndProc函数处理所有发往窗体的消息并且message参数被设置为WM_SOCKET；
3.在WM_SOCKET的消息处理中，分别对FD_ACCEPT、FD_READ和FD_CLOSE事件进行处理；

4.在窗口销毁消息(WM_DESTROY)的处理函数中，我们关闭监听套接字，清除Windows Socket library

下面这张用于WSAAsyncSelect函数的网络事件类型表可以让你对各个网络事件有更清楚的认识：
表1

FD_READ 应用程序想要接收有关是否可读的通知，以便读入数据
FD_WRITE 应用程序想要接收有关是否可写的通知，以便写入数据
FD_OOB 应用程序想接收是否有带外（OOB）数据抵达的通知
FD_ACCEPT 应用程序想接收与进入连接有关的通知
FD_CONNECT 应用程序想接收与一次连接或者多点join操作完成的通知
FD_CLOSE 应用程序想接收与套接字关闭有关的通知
FD_QOS 应用程序想接收套接字“服务质量”（QoS）发生更改的通知
FD_GROUP_QOS     应用程序想接收套接字组“服务质量”发生更改的通知（现在没什么用处，为未来套接字组的使用保留）
FD_ROUTING_INTERFACE_CHANGE 应用程序想接收在指定的方向上，与路由接口发生变化的通知
FD_ADDRESS_LIST_CHANGE     应用程序想接收针对套接字的协议家族，本地地址列表发生变化的通知

使用步骤如下：

a、 创建事件对象来接收网络事件：

WSAEVENT WSACreateEvent( void );

该函数的返回值为一个事件对象句柄，它具有两种工作状态：已传信(signaled)和未传信(nonsignaled)以及两种工作模式：人工重设(manual reset)和自动重设(auto reset)。默认未未传信的工作状态和人工重设模式。

b、将事件对象与套接字关联，同时注册事件，使事件对象的工作状态从未传信转变未已传信。

int WSAEventSelect( SOCKET s,WSAEVENT hEventObject,long lNetworkEvents );
s为套接字
hEventObject为刚才创建的事件对象句柄

lNetworkEvents为掩码，定义如上面所述

c、I/O处理后，设置事件对象为未传信
BOOL WSAResetEvent( WSAEVENT hEvent );
Hevent为事件对象

成功返回TRUE，失败返回FALSE。

d、等待网络事件来触发事件句柄的工作状态：

DWORD WSAWaitForMultipleEvents( DWORD cEvents,const WSAEVENT FAR * lphEvents, BOOL fWaitAll,DWORD dwTimeout, BOOL fAlertable );
lpEvent为事件句柄数组的指针
cEvent为为事件句柄的数目，其最大值为WSA_MAXIMUM_WAIT_EVENTS
fWaitAll指定等待类型：TRUE：当lphEvent数组重所有事件对象同时有信号时返回；
FALSE：任一事件有信号就返回。
dwTimeout为等待超时（毫秒）

fAlertable为指定函数返回时是否执行完成例程

nIndex=WSAWaitForMultipleEvents(…);

MyEvent=EventArray[Index- WSA_WAIT_EVENT_0];

事 件选择模型也比较简单，实现起来也不是太复杂，它的基本思想是将每个套接字都和一个WSAEVENT对象对应起来，并且在关联的时候指定需要关注的哪些网 络事件。一旦在某个套接字上发生了我们关注的事件（FD_READ和FD_CLOSE），与之相关联的WSAEVENT对象被Signaled。程序定义 了两个全局数组，一个套接字数组，一个WSAEVENT对象数组，其大小都是MAXIMUM_WAIT_OBJECTS（64），两个数组中的元素一一对 应。
同样的，这里的程序没有考虑两个问题，一是不能无条件的调用accept，因为我们支持的并发连接数有限。解决方法是将套接字按 MAXIMUM_WAIT_OBJECTS分组，每MAXIMUM_WAIT_OBJECTS个套接字一组，每一组分配一个工作者线程；或者采用 WSAAccept代替accept，并回调自己定义的Condition Function。第二个问题是没有对连接数为0的情形做特殊处理，程序在连接数为0的时候CPU占用率为100%。

 1 SOCKET       Socket[WSA_MAXIMUM_WAIT_EVENTS];
 2 WSAEVENT   Event[WSA_MAXINUM_WAIT_EVENTS];
 3 SOCKET    Accept, Listen;
 5 DWORD     EventTotal = 0;
 6 DWORD     Index;
 7 
 8 //Set up a TCP socket for listening on port 5150
 9 Listen = socket(PF_INET,SOCK_STREAM,0);
10 
11 InternetAddr.sin_family      = AF_INET;
12 InternetAddr.sin_addr.s_addr = htonl(INADDR_ANY);
13 InternetAddr.sin_port        = htons(5150);
14 
15 bind(Listen,(PSOCKADDR) &InternetAddr,sizeof(InternetAddr));
16 
17 NewEvent = WSACreateEvent();
18 
19 WSAEventSelect(Listen,NewEvnet,FD_ACCEPT|FD_CLOSE);
20 
21 listen(Listen,5);
22 
23 Socket[EventTotal] = Listen;
24 Event[EventTotal] = NewEvent;
25 EventTotal++;
26 
27 while (TRUE)
28 {
29     //Wait for network events on all sockets
30     Index = WSAWaitForMultipleEvents(EventTotal,EventArray,FALSE,WSA_INFINITE,FALSE);
31 
32     WSAEnumNewWorkEvents(SocketArray[Index-WSA_WAIT_EVENT_0],
33         EventArray[Index-WSA_WAIT_EVENT_0],
34         &NetworkEvents);
35     //Check for FD_ACCEPT messages
36     if (NetworkEvents.lNetworkEvents & FD_ACCEPT)
37     {
38         if (NetworkEvents.iErrorCode[FD_ACCEPT_BIT] !=0)
39         {
40             //Error
41             break;
42         }
43         //Accept a new connection and add it to the socket and event lists
44         Accept = accept(SocketArray[Index-WSA_WAIT_EVENT_0],NULL,NULL);
45 
46         //We cannot process more than WSA_MAXIMUM_WAIT_EVENTS sockets ,
47         //so close the accepted socket
48         if (EventTotal > WSA_MAXIMUM_WAIT_EVENTS)
49         {
50             printf("..");
51             closesocket (Accept);
52             break;
53         }
54         NewEvent = WSACreateEvent();
55 
56         WSAEventSelect(Accept,NewEvent,FD_READ|FD_WRITE|FD_CLOSE);
57 
58         Event[EventTotal] = NewEvent;
59         Socket[EventTotal]= Accept;
60         EventTotal++;
61         prinrt("Socket %d connect\n",Accept);
62     }
63     //Process FD_READ notification
64     if (NetworkEvents.lNetwoAD)rkEvents & FD_RE
65     {
66         if (NetworkEvents.iErrorCode[FD_READ_BIT !=0])
67         {
68             //Error
69             break;
70         }
71 
72         //Read data from the socket
73         recv(Socket[Index-WSA_WAIT_EVENT_0],buffer,sizeof(buffer),0);
74     }
75     //process FD_WRITE notitication
76     if (NetworkEvents.lNetworkEvents & FD_WRITE)
77     {
78         if (NetworkEvents.iErrorCode[FD_WRITE_BIT] !=0)
79         {
80             //Error
81             break;
82         }
83         send(Socket[Index-WSA_WAIT_EVENT_0],buffer,sizeof(buffer),0);
84     }
85     if (NetworkEvents.lNetworkEvents & FD_CLOSE)
86     {
87         if(NetworkEvents.iErrorCode[FD_CLOSE_BIT] !=0)
88         {
89             //Error
90             break;
91         }
92         closesocket (Socket[Index-WSA_WAIT_EVENT_0]);
93         //Remove socket and associated event from the Socket and Event arrays and
94         //decrement eventTotal
95         CompressArrays(Event,Socket,& EventTotal);
96     }
97 }

在异步非阻塞模式下，像accept（WSAAccept），recv（recv，WSARecv，WSARecvFrom）等这样的winsock函数调用后马上返回，而不是等待可用的连接和数据。在阻塞模式下，server往往这样等待client的连接：

while(TRUE)
{
    //wait for a connection
     ClientSocket = accept(ListenSocket,NULL,NULL);
    if(ClientSocket == INVALID_SOCKET)
     {
         ERRORHANDLE
     }
     else
         DoSomething
}

上述代码简单易用，但是缺点在于如果没有client连接的话，accept一直不会返回，而且即使accept成功创建会话套接字，在阻塞方式下，C/S间传输数据依然要将recv，send这类函数放到一个循环中，反复等待数据的到来，这种轮询的方式效率很低。为此，Winsock提供了异步模式的5种I/O模型，这些模型会在有网络事件（如socket收到连接请求，读取收到的数据请求等等）时通过监视集合(select)，事件对象(WSAEventSelect,重叠I/O)，窗口消息(WSAAsyncSelect)，回调函数(重叠I/O),完成端口的方式通知程序，告诉我们可以“干活了”，这样的话大大的提高了执行效率，程序只需枕戈待旦，兵来将挡水来土掩，通知我们来什么网络事件，就做相应的处理即可。

2.WSAEventSelect模型的使用

WSAEventSelect模型其实很简单，就是将一个事件对象同一个socket绑定并设置要监视的网络事件，当这个socket有我们感兴趣的网络事件到达时，ws2_32.dll就将这个事件对象置为受信状态(signaled)，在程序中等待这个事件对象受信后，根据网络事件类型做不同的处理。如果对线程同步机制有些了解的话，这个模型很容易理解，其实就是CreateEvent系列的winsock版。

无代码无真相，具体API的参数含义可以参考MSDN，MSDN上对这个模型解释的非常详尽。
// 使用WSAEventSelect的代码片段，百度贴吧字数限制，略去错误处理及界面操作
    // 为了能和多个客户端通信，使用两个数组分别记录所有通信的会话套接字
    // 以及和这些套接字绑定的事件对象
    // WSA_MAXIMUM_WAIT_EVENTS是系统内部定义的宏，值为64

     SOCKET g_sockArray[WSA_MAXIMUM_WAIT_EVENTS];
     WSAEVENT g_eventArray[WSA_MAXIMUM_WAIT_EVENTS];

    // 事件对象计数器
    int nEventTotal = 0;

    // 创建监听套接字sListenSocket，并对其绑定端口和本机ip 代码省去
     ........

    // 设置sListenSocket为监听状态
     listen(sListenSocket, 5);

    // 创建事件对象，同CreateEvent一样，event创建后被置为非受信状态
     WSAEVENT acceptEvent = WSACreateEvent();

    // 将sListenSocket和acceptEvent关联起来
    // 并注册程序感兴趣的网络事件FD_ACCEPT 和 FD_CLOSE
    // 这里由于是在等待客户端connect，所以FD_ACCEPT和FD_CLOSE是我们关心的
     WSAEventSelect(sListenSocket, acceptEvent, FD_ACCEPT|FD_CLOSE);

    // 添加到数组中
     g_eventArray[nEventTotal] = acceptEvent;
     g_sockArray[nEventTotal] = sListenSocket;    
     nEventTotal++;

    // 处理网络事件
    while(TRUE)
     {
        // 由于第三个参数是 FALSE，所以 g_eventArray 数组中有一个元素受信 WSAWaitForMultipleEvents 就返回
        // 注意 返回值 nIndex 减去 WSA_WAIT_EVENT_0 的值才是受信事件在数组中的索引。
        // 如果有多个事件同时受信，函数返回索引值最小的那个。
        // 由于第四个参数指定 WSA_INFINITE ，所以没有对象受信时会无限等待。
        int nIndex = WSAWaitForMultipleEvents(nEventTotal, g_eventArray, FALSE, WSA_INFINITE, FALSE);

        // 取得受信事件在数组中的位置。
         nIndex = nIndex - WSA_WAIT_EVENT_0;

        // 判断受信事件 g_eventArray[nIndex] 所关联的套接字 g_sockArray[nIndex] 的网络事件类型
        // MSDN中说如果事件对象不是NULL, WSAEnumNetworkEvents 会帮咱重置该事件对象为非受信，方便等待新的网络事件
        // 也就是说这里的 g_eventArray[nIndex] 变为非受信了，所以程序中不用再调用 WSAResetEvent了
        // WSANETWORKEVENTS 这个结构中 记录了关于g_sockArray[nIndex] 的网络事件和错误码
         WSANETWORKEVENTS event;
         WSAEnumNetworkEvents(g_sockArray[nIndex], g_eventArray[nIndex], &event);

        // 这里处理 FD_ACCEPT 这个网络事件
        // event.lNetWorkEvents中记录的是网络事件类型
        if(event.lNetworkEvents & FD_ACCEPT)
         {
            // event.iErrorCode是错误代码数组，event.iErrorCode[FD_ACCEPT_BIT] 为0表示正常
            if(event.iErrorCode[FD_ACCEPT_BIT] == 0)
             {
                // 连接数超过系统约定的范围
                if(nEventTotal > WSA_MAXIMUM_WAIT_EVENTS)
                 {    
                     ErrorHandle...
                    continue;
                 }
                // 没有问题就可以accept了
                 SOCKET sAcceptSocket = accept(g_sockArray[nIndex], NULL, NULL);

                // 新建的会话套接字用于C/S间的数据传输，所以这里关心FD_READ,FD_CLOSE,FD_WRITE三个事件
                 WSAEVENT event = WSACreateEvent();
                 WSAEventSelect(sAcceptSocket, event, FD_READ|FD_CLOSE|FD_WRITE);

                // 将新建的会话套接字及与该套接字关联的事件对象添加到数组中
                 g_eventArray[nEventTotal] = event;
                 g_sockArray[nEventTotal] = sAcceptSocket;    
                 nEventTotal++;
             }

            //event.iErrorCode[FD_ACCEPT_BIT] != 0 出错了
             else
             {
                 ErrorHandle...
                break;
             }
         }


        // 这里处理FD_READ通知消息，当会话套接字上有数据到来时，ws2_32.dll会记录该事件
         else if(event.lNetworkEvents & FD_READ)    
         {
            if(event.iErrorCode[FD_READ_BIT] == 0)
             {
                int nRecv = recv(g_sockArray[nIndex], buffer, nbuffersize, 0);
                if(nRecv == SOCKET_ERROR)                
                 {
                    // 为了程序更鲁棒，这里要特别处理一下WSAEWOULDBLOCK这个错误
                    // MSDN中说在异步模式下有时recv(WSARecv)读取时winsock的缓冲区中没有数据，导致recv立即返回
                    // 错误码就是 WSAEWOULDBLOCK,但这时程序并没有出问题，在有新的数据到来时recv还是可以读到数据的
                    // 所以不能仅仅根据recv返回值是SOCKET_ERROR就认为出错从而执行退出操作。
                    //如果错误码不是WSAEWOULDBLOCK 则表示真的出错了
                    if(WSAGetLastError() != WSAEWOULDBLOCK)
                     {    
                         ErrorHandle...
                        break;
                     }
                 }
                // 没出任何错误
                 else
                     DoSomeThing...
             }

            // event.iErrorCode[FD_READ_BIT] != 0
             else
             {
                 ErrorHandle...
                break;
             }
         }


        // 这里处理FD_CLOSE通知消息
        // 当连接被关闭时，ws2_32.dll会记录FD_CLOSE事件
         else if(event.lNetworkEvents & FD_CLOSE)
         {
            if(event.iErrorCode[FD_CLOSE_BIT] == 0)
             {
                 closesocket(g_sockArray[nIndex]);
                                 // 将g_sockArray[nIndex]从g_sockArray数组中删除
                for(int j=nIndex; j<nEventTotal-1; j++)
                     g_sockArray[j] = g_sockArray[j+1];    
                 nEventTotal--;
             }

            // event.iErrorCode[FD_CLOSE_BIT] != 0
             else
             {
                 ErrorHandle...
                break;
             }
         }


        // 处理FD_WRITE通知消息
        // FD_WRITE事件其实就是ws2_32.dll告诉我们winsock的缓冲区已经ok，可以发送数据了
        // 同recv一样，send(WSASend)的返回值也要对SOCKET_ERROR特殊判断一下 WSAEWOULDBLOCK
         else if(event.lNetworkEvents & FD_WRITE)        
         {
            //关于FD_WRITE的讨论在下面。
         }
     }

    // 如果出错退出循环 则将套接字数组中的套接字与事件对象统统解除关联
    // 给WSAEventSelect的最后一个参数传0可以解除g_sockArray[nIndex]和g_eventArray[nIndex]的关联
    // 解除关联后,ws2_32.dll将停止记录g_sockArray[nIndex]这个套接字的网络事件
    // 退出时还要关闭所有创建的套接字和事件对象

    for(int i = 0; i < nEventTotal; i++)
     {
         WSAEventSelect(g_sockArray[i], g_eventArray[i], 0);    
         closesocket(g_sockArray[i]);
         WSACloseEvent(g_eventArray[i]);
     }

     nEventTotal = 0;

     DoSomethingElse....

3.FD_WRITE 事件的触发

常见的网络事件中，FD_ACCEPT和FD_READ都比较好理解。一开始我唯一困惑的就是FD_WRITE,搞不清楚到底什么时候才会触发这个网络事件，后来仔细查了MSDN又看了一些文章并测试了下，终于搞懂了FD_WRITE的触发机制。

下面是MSDN中对FD_WRITE触发机制的解释：

The FD_WRITE network event is handled slightly differently. An FD_WRITE network event is recorded when a socket is first connected with connect/WSAConnect or accepted with accept/WSAAccept, and then after a send fails with WSAEWOULDBLOCK and buffer space becomes available. Therefore, an application can assume that sends are possible starting from the first FD_WRITE network event setting and lasting until a send returns WSAEWOULDBLOCK. After such a failure the application will find out that sends are again possible when an FD_WRITE network event is recorded and the associated event object is set

FD_WRITE事件只有在以下三种情况下才会触发

①client 通过connect（WSAConnect）首次和server建立连接时，在client端会触发FD_WRITE事件

②server通过accept（WSAAccept）接受client连接请求时，在server端会触发FD_WRITE事件

③send（WSASend）/sendto（WSASendTo）发送失败返回WSAEWOULDBLOCK，并且当缓冲区有可用空间时，则会触发FD_WRITE事件

①②其实是同一种情况，在第一次建立连接时，C/S端都会触发一个FD_WRITE事件。

主要是③这种情况：send出去的数据其实都先存在winsock的发送缓冲区中，然后才发送出去，如果缓冲区满了，那么再调用send（WSASend,sendto,WSASendTo）的话，就会返回一个 WSAEWOULDBLOCK的错误码，接下来随着发送缓冲区中的数据被发送出去，缓冲区中出现可用空间时，一个 FD_WRITE 事件才会被触发，这里比较容易混淆的是 FD_WRITE 触发的前提是 缓冲区要先被充满然后随着数据的发送又出现可用空间，而不是缓冲区中有可用空间，也就是说像如下的调用方式可能出现问题

else if(event.lNetworkEvents & FD_WRITE)
{
    if(event.iErrorCode[FD_WRITE_BIT] == 0)
     {
         send(g_sockArray[nIndex], buffer, buffersize);
         ....
     }
     else
     {
     }
}

问题在于建立连接后 FD_WRITE 第一次被触发， 如果send发送的数据不足以充满缓冲区，虽然缓冲区中仍有空闲空间，但是 FD_WRITE 不会再被触发，程序永远也等不到可以发送的网络事件。

基于以上原因，在收到FD_WRITE事件时，程序就用循环或线程不停的send数据，直至send返回WSAEWOULDBLOCK，表明缓冲区已满，再退出循环或线程。当缓冲区中又有新的空闲空间时，FD_WRITE 事件又被触发，程序被通知后又可发送数据了。

上面代码片段中省略的对 FD_WRITE 事件处理

P.S.

1.WSAWaitForMultipleEvents内部调用的还是WaitForMulipleObjectsEx，MSDN中说使用WSAEventSelect模型等待时是不占cpu时间的，这也是效率比阻塞winsock高的原因。

2.WSAAsycSelect的用法和WSAEventSelect类似，不同的是网络事件的通知是以windows消息的方式发送到指定的窗口。

转自http://210.40.7.188/Source/yckz.asp

计算机研究生开放研究 《网络远程监控的VC++6编程示例》 美国GeneChiu基金资助 网络远程监控的VC++6编程示例

1 远程关机 编程：研究生 吴勇 这是一个可作服务器也可作客户的使用WinSock进行网络远程关机的VC++6程序：

#include "assert.h" #include "iostream.h" CString m_strServer; UINT m_nPort; CString m_strUser; CString m_strPass; SOCKET m_hSocket; SOCKADDR_IN m_addr; void StartUp(); void CleanUp(); void OnOK(); void SendToServer(); void RecvFromServer(); void StartUpS(); void CreateSocket(); void BindSocket(); void Listen_Recv(); void CleanUpS(); int p=0; char buff[100]; char buff1[100]; int strlen(char str[]); char b[100]; char ip[100]; int an=0; void main(){ cout<<"请输入1.开启服务器,输入2.运行客户端:"; cin>>an; if (an==2) { cout<<"请输入服务器IP:"; cin>>ip; m_strServer = ip; m_nPort = 2350; StartUp(); char cc; do{ OnOK(); cout<<"已经与服务器连接成功，向服务器发送数据\n"; cout<<"请输入 G 关机:"; cin>>b; m_strUser =b; SendToServer(); cout<<"发送成功"; RecvFromServer(); cout<<"\n本次通信完成;再来吗(y/n)\n";cin>>cc; }while (cc != 'n'); CleanUp(); } if(an==1) { StartUpS(); CreateSocket(); BindSocket(); Listen_Recv(); CleanUpS(); } } void OnOK() { if(m_hSocket != NULL){ closesocket(m_hSocket); m_hSocket = NULL; } if(m_hSocket == NULL){ m_hSocket = socket(AF_INET, SOCK_STREAM,0); assert(m_hSocket != NULL); } m_addr.sin_family = AF_INET; m_addr.sin_addr.S_un.S_addr = inet_addr(m_strServer.GetBuffer(0)); m_addr.sin_port = htons(m_nPort); int ret = 0; int error = 0; ret = connect(m_hSocket, (LPSOCKADDR)&m_addr, sizeof(m_addr)); if(ret == SOCKET_ERROR){ TRACE("Connect Error: %d \n", (error = WSAGetLastError())); if(error == 10061) AfxMessageBox(_T("请确认服务器确实已经打开并工作在同样的端口！")); return ; } } void SendToServer(){ CString str; str += m_strUser; int ret = send(m_hSocket, str, str.GetLength(), 0); if(ret != str.GetLength()){ TRACE("Send data error: %d\n", WSAGetLastError()); return ; } } void RecvFromServer(){ int ret = recv(m_hSocket, buff1,100, 0); if(ret == 0){ TRACE("Recv data error: %d\n", WSAGetLastError()); return ; } // buff1[ret] = '\0'; // cout< 2 远程监控程序 编程：研究生 唐郑熠 这个个远程监控程序，以命令行“ldc -s”运行时，是作为服务器运行； 以命令行“ldc –c IP”(IP为服务器IP地址)运行时，是作为客户端运行。 服务器向客户端发送指令“A”或“B”，若发送指令A，则客户端控制计算机自动关机； 若发送指令B，则将计算机所有的击键记录下来发送给服务器。 其中，ASCII值为32～128的可见ASCII字符直接输出， 其它的不可见ASCII字符以“(%d)”的形式输出，即括号加上该字符的ASCII值。

#include "afxwin.h" #include "iostream.h" #include "assert.h" #include "winsock.h" #include "stdio.h" #include "conio.h" #include "windows.h" #pragma comment(lib, "wsock32") //编译连接时使用静态连接库wsock32.lib UINT m_nPort; //服务器端口号--16位整数 SOCKET m_hSocket; //服务器进程套接字类 SOCKADDR_IN m_addr; //套接字地址结构 CString m_strServer; //服务器IP地址 //SOCKET m_hSocket; //服务器进程套接字类 //SOCKADDR_IN m_addr; //套接字地址结构 char cmd; void StartUp(); //初始化Winsock的函数:启动Winsock void CreateSocket(); //使用socket函数建立服务器进程的流（TCP）套接字 void BindSocket(); //使用bind函数绑定IP地址到套接字，使网络上可识别该套接字 void Listen_Recv(); //将套接字置入监听模式并准备接受连接进行通信 void CleanUp(); //终止对Winsock DLL的使用，释放资源 void OnOK(); //建立TCP通信套接字并与服务器连接 //void SendToServer(); //向服务器发送数据 //void RecvFromServer(); //向服务器发送数据 void server(); void client(); void shutDown(); //从str的头一个字符往后检查，直到字符'\0'(其值为0)为止，即返回字符串str字符'\0'前的长 int strlen(char str[]); int main(int argc, char *argv[]) { if( argc == 3 ) { if( !strcmp( argv[1], "-c") ) { m_nPort = 2350; m_strServer = argv[2]; client(); } } else if ( argc > 3 ){// invalid args. puts("For server: \n\tusage: echocs [-d]\nFor client:\n\tusage: echocs -c host\n"); return 1; } else { m_nPort = 2350; server(); } return 0; } void server() { printf("2007级唐郑熠—远程控制服务器\n\n"); /** 1 应用程序初始化：注册wsock.dll **/ StartUp(); /** 2 使用socket函数建立服务器进程的流（TCP）套接字： **/ CreateSocket(); /** 3 使用bind函数绑定IP地址到套接字，使网络上可识别该套接字，bind原型为 int bind(SOCKET s, const struct sockaddr* name, int namelen) 其中：s为等待连接的未绑定套接字，name为套接字地址结构，更为有用的是 SOCKADDR_IN，用来标识TCP/IP协议下的地址，这时通过强制类型转换可将 SOCKADDR_IN结构转换为sockaddr结构 **/ BindSocket(); //UpdateData();//更新用户在编辑框里对端口的改变,MFC对话框用 /** 4 将套接字置入监听模式并准备接受连接进行通信：bind只是将套接字与地址关联在一起； 而使套接字进入等候连接则由函数listen完成，listen的原型为： **/ Listen_Recv(); /** 5 关闭套接字，终止对Winsock DLL的使用，释放资源 **/ CleanUp(); } //初始化Winsock的函数:启动Winsock void StartUp() { //初始化全局变量 m_nPort = 2350; m_hSocket = NULL; //初始化winsock WSADATA wsaData; WORD version = MAKEWORD(2, 0); // //调用WSAStartup函数对Winsock DLL进行初始化，协商Winsock版本，分配资源 int ret = WSAStartup(version, &wsaData); if(ret != 0)cout<<"初始化错误!\n"; } void CreateSocket() { //先关闭已经建立的套接字 if(m_hSocket != NULL){ closesocket(m_hSocket); m_hSocket = NULL; } //用socket（构造）函数建立流类型（TCP）套接字 if(m_hSocket == NULL){ m_hSocket = socket(AF_INET, SOCK_STREAM,0); assert(m_hSocket != NULL); //C语言函数，进行判断，若不真，则做出错处理 } } void BindSocket(){ //给服务器结构地址m_addr赋值： m_addr.sin_family = AF_INET; //表示该socket处于Internet域 m_addr.sin_port = htons(m_nPort); //指定服务端口 //sin_addr把一个IP地址保存为4字节的无符号整数， m_addr.sin_addr.S_un.S_addr = INADDR_ANY; //本机测试时可用，即127.0.0.1 //若使用实际IP地址，可用函数inet_addr将其转换为4字节的无符号整数 // m_addr.sin_addr.S_un.S_addr=inet_addr("210.40.7.131"); int error = 0; int ret = bind(m_hSocket, (LPSOCKADDR)&m_addr, sizeof(m_addr)); if(ret == SOCKET_ERROR){ cout<<"Bind Error!\n";//, (error = WSAGetLastError())); return ; } } void Listen_Recv(){ //cout<<"请按一键开始运行服务器"; //char cc;cin>>cc; //while(1){//服务器永远循环服务 //侦听 int ret = listen(m_hSocket, 2); if(ret == SOCKET_ERROR){ cout<<"Listen Error: %d \n";//, (error = WSAGetLastError())); return ; } // SOCKET s = accept(m_hSocket, NULL, NULL); if(s == SOCKET_ERROR){ cout<<"Accept Error: %d \n";//, (error = WSAGetLastError())); return ; } //cout<<"客户连接成功！\n"; //接受客户数据 char buff[1]; ret = recv(s, buff, 1, 0); if(ret == 0 || ret == SOCKET_ERROR ){ cout<<"Recv data error: %d\n";//, WSAGetLastError()); return ; } printf("请选择 A.远程关机 B.远程监控键盘:"); scanf("%c", &buff[0]); cmd = buff[0]; ret = send(s, buff, 1, 0); if (cmd == 'B' || cmd == 'b') { printf("监听到的内容：\n"); while (1) { //侦听 int ret = listen(m_hSocket, 2); if(ret == SOCKET_ERROR){ cout<<"Listen Error: %d \n";//, (error = WSAGetLastError())); return ; } // SOCKET s = accept(m_hSocket, NULL, NULL); if(s == SOCKET_ERROR){ cout<<"Accept Error: %d \n";//, (error = WSAGetLastError())); return ; } //cout<<"客户连接成功！\n"; //接受客户数据 char buff[1]; ret = recv(s, buff, 1, 0); if(ret == 0 || ret == SOCKET_ERROR ){ cout<<"Recv data error: %d\n";//, WSAGetLastError()); return ; } int cnt = 0; if (buff[0] >= 32 && buff[0] <= 128) { printf("%c", buff[0]); cnt++; } else { if (buff[0] == 13) { printf("\n"); } else { printf("(%d)", buff[0]); } cnt++; } } } /** 4 处理客户消息 **/ ///** 回声服务：向客户返回消息(20个字节) //ret = send(s, buff, 20, 0); //**/ // //cout<<"处理完成；服务器重新等待客户连接！\n"; //} } //应用程序关闭套接字后，终止对Winsock DLL的使用，释放资源 void CleanUp() { if (WSACleanup() != 0){ cout<<"UnInitilize Error:%d\n";//, WSAGetLastError()); } } void client(){ // m_strServer = "127.0.0.1"; //_T("127.0.0.1"); // m_nPort = 2350; // m_strUser = "贵大";//ware"; // m_strPass = "Guizhou Univ"; printf("2007级唐郑熠—远程控制客户端\n\n"); StartUp(); //初始化Winsock的函数:启动Winsock char cc; char buff[1]; OnOK();//建立通信套接字 //cout<<"已经与服务器连接成功，向服务器发送数据\n"; int ret = send(m_hSocket, buff, 1, 0); if(ret != 1){ TRACE("Send data error: %d\n", WSAGetLastError()); // cout<<"Send data error: %d\n";//, WSAGetLastError()); return ; } ret = recv(m_hSocket, buff, 1, 0); if(ret == 0){ TRACE("Recv data error: %d\n", WSAGetLastError()); // cout<<"Recv data error: %d\n";//, WSAGetLastError()); return ; } cmd = buff[0]; if (cmd == 'A' || cmd == 'a') { shutDown(); } else { char ch; while(1) { if (kbhit()) { OnOK();//建立通信套接字 ch = getch(); buff[0] = ch; int ret = send(m_hSocket, buff, 1, 0); if(ret != 1) { TRACE("Send data error: %d\n", WSAGetLastError()); // cout<<"Send data error: %d\n";//, WSAGetLastError()); return ; } } } } /*SendToServer();//向服务器发送数据 cout<<"发送成功，服务器返回数据：\n\n"; RecvFromServer();//从服务器接收数据*/ //cout<<"\n本次通信完成;再来吗(y/n)\n";cin>>cc; CleanUp(); //终止对Winsock DLL的使用，释放资源 } //调用socket建立TCP通信套接字并与服务器连接 void OnOK() { //调用socket建立TCP通信套接字 if(m_hSocket != NULL){ closesocket(m_hSocket); m_hSocket = NULL; } if(m_hSocket == NULL){ m_hSocket = socket(AF_INET, SOCK_STREAM,0); assert(m_hSocket != NULL); } //UpdateData(); //给套接字地址结构赋值 m_addr.sin_family = AF_INET; m_addr.sin_addr.S_un.S_addr = inet_addr(m_strServer.GetBuffer(0)); m_addr.sin_port = htons(m_nPort); int ret = 0;// int error = 0; //用connect建立连接,连接成功，返回0，否则返回SOCKET_ERROR ret = connect(m_hSocket, (LPSOCKADDR)&m_addr, sizeof(m_addr)); if(ret == SOCKET_ERROR){//出错处理 TRACE("Connect Error: %d \n", (error = WSAGetLastError())); // cout<<"Connect Error!\n";//, (error = WSAGetLastError())); if(error == 10061) // AfxMessageBox(_T("请确认服务器确实已经打开并工作在同样的端口！")); cout<<"请确认服务器确实已经打开并工作在同样的端口！\n"; return ; } } /*void SendToServer(){ // CString str; str += m_strUser; str += m_strPass; //发送数据，如成功，返回发送的字节数 int ret = send(m_hSocket, str, str.GetLength(), 0); if(ret != str.GetLength()){ TRACE("Send data error: %d\n", WSAGetLastError()); // cout<<"Send data error: %d\n";//, WSAGetLastError()); return ; } }*/ /* void RecvFromServer(){ char buff[256]; /** 接受数据recv函数的返回值： 如无错误，返回接到的字节数(bytes received) 如连接已关闭，返回0 要不然，返回出错处理值：SOCKET_ERROR **/ /* int ret = recv(m_hSocket, buff, 256, 0); if(ret == 0){ TRACE("Recv data error: %d\n", WSAGetLastError()); // cout<<"Recv data error: %d\n";//, WSAGetLastError()); return ; } buff[ret] = '\0';//ASCII值为0的字符：'\0' cout<<buff<<endl;//显示服务器送回数据 //AfxMessageBox(buff); }*/ //应用程序关闭套接字后，终止对Winsock DLL的使用，释放资源 /*void CleanUp() { if (WSACleanup() != 0){ TRACE("UnInitilize Error:%d\n", WSAGetLastError()); // cout<<"UnInitilize Error:%d\n";//, WSAGetLastError()); } }*/ //从str的头一个字符往后检查，直到字符'\0'(其值为0)为止，即返回字符串str字符'\0'前的长 int strlen(char str[]){ int i=0; while(str[i])i++; return i; } void shutDown() { TOKEN_PRIVILEGES tkp, tkpnewbutignored; HANDLE hdltokenhandle; LUID tmpluid; BOOL rc; DWORD lbufferneeded; HANDLE hdlprocesshandle = GetCurrentProcess(); rc = OpenProcessToken(hdlprocesshandle, TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, &hdltokenhandle); rc = LookupPrivilegeValue("", "SeShutdownPrivilege", &tmpluid); tkp.PrivilegeCount = 1; tkp.Privileges[0].Luid = tmpluid; tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; rc = AdjustTokenPrivileges(hdltokenhandle, FALSE, &tkp, sizeof(tkpnewbutignored), &tkpnewbutignored, &lbufferneeded); ExitWindowsEx(EWX_SHUTDOWN|EWX_FORCE, 0); }

厚积薄发 2011-06-10 13:58 发表评论

]]>

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/hionceshine/archive/2008/11/25/3362669.aspx

摘自《Networking Programming for Microsoft Windows》第八章

“完成端口”模型是迄今为止最为复杂的一种I/O模型。然而，假若一个应用程序同时需要管理为数众多的套接字，那么采用这种模型，往往可以达到最佳的系统性能！

从本质上说，完成端口模型要求我们创建一个Win32完成端口对象，通过指定数量的线程，对重叠I/O请求进行管理，以便为已经完成的重叠I/O请求提供服务。

使用这种模型之前，首先要创建一个I/O完成端口对象，用它面向任意数量的套接字句柄，管理多个I/O请求。要做到这一点，需要调用CreateCompletionPort函数。
该函数定义如下：

HANDLE CreateIoCompletionPort(
    HANDLE FileHandle,
    HANDLE ExistingCompletionPort,
    ULONG_PTR CompletionKey,
    DWORD NumberOfConcurrentThreads
);

在我们深入探讨其中的各个参数之前，首先要注意该函数实际用于两个明显有别的目的：
1. 用于创建一个完成端口对象。
2. 将一个句柄同完成端口关联到一起。

最开始创建一个完成端口时，唯一感兴趣的参数便是NumberOfConcurrentThreads（并发线程的数量）；前面三个参数都会被忽略。NumberOfConcurrentThreads参数的特殊之处在于，它定义了在一个完成端口上，同时允许执行的线程数量。理想情况下，我们希望每个处理器各自负责一个线程的运行，为完成端口提供服务，避免过于频繁的线程“场景”切换。若将该参数设为0，表明系统内安装了多少个处理器，便允许同时运行多少个线程！可用下述代码创建一个I/O完成端口：

hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);

该语句的作用是返回一个句柄，在为完成端口分配了一个套接字句柄后，用来对那个端口进行标定（引用）。

一、工作者线程与完成端口
成功创建一个完成端口后，便可开始将套接字句柄与对象关联到一起。但在关联套接字之前，首先必须创建一个或多个“工作者线程”，以便在I/O请求投递给完成端口对象后，为完成端口提供服务。在这个时候，大家或许会觉得奇怪，到底应创建多少个线程，以便为完成端口提供服务呢？这实际正是完成端口模型显得颇为“复杂”的一个方面，因为服务I/O请求所需的数量取决于应用程序的总体设计情况。在此要记住的一个重点在于，在我们调用CreateIoCompletionPort时指定的并发线程数量，与打算创建的工作者线程数量相比，它们代表的并非同一件事情。早些时候，我们曾建议大家用CreateIoCompletionPort函数为每个处理器
都指定一个线程（处理器的数量有多少，便指定多少线程）以避免由于频繁的线程“场景”交换活动，从而影响系统的整体性能。CreateIoCompletionPort函数的NumberOfConcurrentThreads参数明确指示系统：在一个完成端口上，一次只允许n个工作者线程运行。假如在完成端口上创建的工作者线程数量超出n个，那么在同一时刻，最多只允许n个线程运行。但实际上，在一段较短的时间内，系统有可能超过这个值，但很快便会把它减少至事先在CreateIoCompletionPort函数中设定的值。那么，为何实际创建的工作者线程数量有时要比CreateIoCompletionPort函数设定的多一些呢？这样做有必要吗？如先前所述，这主要取决于
应用程序的总体设计情况。假定我们的某个工作者线程调用了一个函数，比如Sleep或WaitForSingleObject，但却进入了暂停（锁定或挂起）状态，那么允许另一个线程代替它的位置。换言之，我们希望随时都能执行尽可能多的线程；当然，最大的线程数量是事先在CreateIoCompletionPort调用里设定好的。这样一来，假如事先预计到自己的线程有可能暂时处于停顿状态，那么最好能够创建比CreateIoCompletionPort的NumberOfConcurrentThreads参数的值多的线程，以便到时候充分发挥系统的潜力。一旦在完成端口上拥有足够多的工作者线程来为I/O请求提供服务，便可着手将套接字句柄同完成端口关联到一起。这要求我们在一个现有的完成端口上，调用CreateIoCompletionPort函数，同时为前三个参数——FileHandle，ExistingCompletionPort和CompletionKey——提供套接字的信息。其中， FileHandle参数指定一个要同完成端口关联在一起的套接字句柄。ExistingCompletionPort参数指定的是一个现有的完成端口。CompletionKey（完成键）参数则指定要与某个特定套接字句柄关联在一起的“单句柄数据”；在这个参数中，应用程序可保存与一个套接字对应的任意类型的信息。之所以把它叫作“单句柄数据”，是由于它只对
应着与那个套接字句柄关联在一起的数据。可将其作为指向一个数据结构的指针，来保存套接字句柄；在那个结构中，同时包含了套接字的句柄，以及与那个套接字有关的其他信息。

根据我们到目前为止学到的东西，首先来构建一个基本的应用程序框架。下面阐述了如何使用完成端口模型，来开发一个ECHO服务器应用。在这个程序中，我们基本上按下述步骤行事：

1) 创建一个完成端口。第四个参数保持为0，指定在完成端口上，每个处理器一次只允许执行一个工作者线程。
2) 判断系统内到底安装了多少个处理器。
3) 创建工作者线程，根据步骤2)得到的处理器信息，在完成端口上，为已完成的I/O请求提供服务。
4) 准备好一个监听套接字，在端口5150上监听进入的连接请求。
5) 使用accept函数，接受进入的连接请求。
6) 创建一个数据结构，用于容纳“单句柄数据”，同时在结构中存入接受的套接字句柄。
7) 调用CreateIoCompletionPort，将自accept返回的新套接字句柄同完成端口关联到一起。通过完成键（CompletionKey）参数，将单句柄数据结构传递给CreateIoCompletionPort。
8) 开始在已接受的连接上进行I/O操作。在此，我们希望通过重叠I/O机制，在新建的套接字上投递一个或多个异步WSARecv或WSASend请求。这些I/O请求完成后，一个工作者线程会为I/O请求提供服务，同时继续处理未来的I/O请求，稍后便会在步骤3 )指定的工作者例程中，体验到这一点。
9) 重复步骤5 ) ~ 8 )，直至服务器中止。

二、完成端口和重叠I/O
将套接字句柄与一个完成端口关联在一起后，便可以套接字句柄为基础，投递发送与接收请求，开始对I/O请求的处理。接下来，可开始依赖完成端口，来接收有关I/O操作完成情况的通知。从本质上说，完成端口模型利用了Win32重叠I/O机制。在这种机制中，象WSASend和WSARecv这样的Winsock API调用会立即返回。此时，需要由我们的应用程序负责在以后的某个时间，通过一个OVERLAPPED结构，来接收调用的结果。在完成端口模型中，要想做到这一点，需要使用GetQueuedCompletionStatus（获取排队完成状态）函数，让一个或多个工作者线程在完成端口上等待。该函数的定义如下：

BOOL GetQueuedCompletionStatus(
    HANDLE CompletionPort,
    LPDWORD lpNumberOfBytes,
    PULONG_PTR lpCompletionKey,
    LPOVERLAPPED* lpOverlapped,
    DWORD dwMilliseconds
);

其中，CompletionPort参数对应于要在上面等待的完成端口。lpNumberOfBytes参数负责在完成了一次I/O操作后（如WSASend或WSARecv），接收实际传输的字节数。lpCompletionKey参数为原先传递进入CreateIoCompletionPort函数的套接字返回“单句柄数据”。如我们早先所述，大家最好将套接字句柄保存在这个“键”（Key）中。lpOverlapped参数用于接收完成的I/O操作的重叠结果。这实际是一个相当重要的参数，因为可用它获取每个I/O操作的数据。而最后一个参数，dwMilliseconds，用于指定调用者希望等待一个完成数据包在完成端口上出现的时间。假如将其设为INFINITE，调用会无休止地等待下去。

三、单句柄数据和单I/O操作数据
一个工作者线程从GetQueuedCompletionStatus这个API调用接收到I/O完成通知后，在lpCompletionKey和lpOverlapped参数中，会包含一些必要的套接字信息。利用这些信息，可通过完成端口，继续在一个套接字上的I/O处理。通过这些参数，可获得两方面重要的套接字数据：单句柄数据，以及单I/O操作数据。其中，lpCompletionKey参数包含了“单句柄数据”，因为在一个套接字首次与完成端口关联到一起的时候，那些数据便与一个特定的套接字句柄对应起来了。这些数据正是我们在进行CreateIoCompletionPort API调用的时候，通过CompletionKey参数传递的。如早先所述，应用程序可通过该参数传递任意类型的数据。通常情况下，应用程序会将与I/O请求有关的套接字句柄保存在这里。lpOverlapped参数则包含了一个OVERLAPPED结构，在它后面跟随“单I/O操作数据”。我们的工作者线程处理一个完成数据包时（将数据原封不动打转回去，接受连接，投递另一个线程，等等），这些信息是它必须要知道的。单I/O操作数据可以是追加到一个OVERLAPPED结构末尾的、任意数量的字节。假如一个函数要求用到一个OVERLAPPED结构，我们便必须将这样的一个结构传递进去，以满足它的要求。要想做到这一点，一个简单的方法是定义一个结构，然后将OVERLAPPED结构作为新结构的第一个元素使用。举个例子来说，可定义下述数据结构，实现对单I/O操作数据的管理：

typedef struct
{
    OVERLAPPED Overlapped;
    WSABUF     DataBuf;
    CHAR       Buffer[DATA_BUFSIZE];
    BOOL       OperationType;
}PER_IO_OPERATION_DATA

该结构演示了通常要与I/O操作关联在一起的某些重要数据元素，比如刚才完成的那个I/O操作的类型（发送或接收请求）。在这个结构中，我们认为用于已完成I/O操作的数据缓冲区是非常有用的。要想调用一个Winsock API函数，同时为其分配一个OVERLAPPED结构，既可将自己的结构“造型”为一个OVERLAPPED指针，亦可简单地撤消对结构中的OVERLAPPED元素的引用。如下例所示：

PER_IO_OPERATION_DATA PerIoData;
// 可像下面这样调用一个函数
  WSARecv(socket, ..., (OVERLAPPED *)&PerIoData);
// 或像这样
  WSARecv(socket, ..., &(PerIoData.Overlapped));

在工作线程的后面部分，等GetQueuedCompletionStatus函数返回了一个重叠结构（和完成键）后，便可通过撤消对OperationType成员的引用，调查到底是哪个操作投递到了这个句柄之上（只需将返回的重叠结构造型为自己的PER_IO_OPERATION_DATA结构）。对单I/O操作数据来说，它最大的一个优点便是允许我们在同一个句柄上，同时管理多个I/O操作（读/写，多个读，多个写，等等）。大家此时或许会产生这样的疑问：在同一个套接字上，真的有必要同时投递多个I/O操作吗？答案在于系统的“伸缩性”，或者说“扩展能力”。例如，假定我们的机器安装了多个中央处理器，每个处理器都在运行一个工作者线程，那么在同一个时
候，完全可能有几个不同的处理器在同一个套接字上，进行数据的收发操作。

最后要注意的一处细节是如何正确地关闭I/O完成端口—特别是同时运行了一个或多个线程，在几个不同的套接字上执行I/O操作的时候。要避免的一个重要问题是在进行重叠I/O操作的同时，强行释放一个OVERLAPPED结构。要想避免出现这种情况，最好的办法是针对每个套接字句柄，调用closesocket函数，任何尚未进行的重叠I/O操作都会完成。一旦所有套接字句柄都已关闭，便需在完成端口上，终止所有工作者线程的运行。要想做到这一点， 需要使用PostQueuedCompletionStatus函数，向每个工作者线程都发送一个特殊的完成数据包。该函数会指示每个线程都“立即结束并退出”。下面是PostQueuedCompletionStatus函数的定义：

BOOL PostQueuedCompletionStatus(
    HANDLE CompletionPort,
    DWORD dwNumberOfBytesTransferred,
    ULONG_PTR dwCompletionKey,
    LPOVERLAPPED lpOverlapped
);

其中，CompletionPort参数指定想向其发送一个完成数据包的完成端口对象。而就dwNumberOfBytesTransferred、dwCompletionKey和lpOverlapped这三个参数来说，每一个都允许我们指定一个值，直接传递给GetQueuedCompletionStatus函数中对应的参数。这样一来，一个工作者线程收到传递过来的三个GetQueuedCompletionStatus函数参数后，便可根据由这三个参数的某一个设置的特殊值，决定何时应该退出。例如，可用dwCompletionPort参数传递0值，而一个工作者线程会将其解释成中止指令。一旦所有工作者线程都已关闭，便可使用CloseHandle函数，关闭完成端口，最终安全退出程序。

注：CreateIoCompletionPort ，PostQueuedCompletionStatus ，GetQueuedCompletionStatus 等函数的用法说明。

Platform SDK: Storage

I/O Completion Ports

I/O completion ports are the mechanism by which an application uses a pool of threads that was created when the application was started to process asynchronous I/O requests. These threads are created for the sole purpose of processing I/O requests. Applications that process many concurrent asynchronous I/O requests can do so more quickly and efficiently by using I/O completion ports than by using creating threads at the time of the I/O request.

I/O完成端口(s)是一种机制，通过这个机制，应用程序在启动时会首先创建一个线程池，然后该应用程序使用线程池处理异步I/O请求。这些线程被创建的唯一目的就是用于处理I/O请求。对于处理大量并发异步I/O请求的应用程序来说，相比于在I/O请求发生时创建线程来说，使用完成端口(s)它就可以做的更快且更有效率。

The CreateIoCompletionPort function associates an I/O completion port with one or more file handles. When an asynchronous I/O operation started on a file handle associated with a completion port is completed, an I/O completion packet is queued to the port. This can be used to combine the synchronization point for multiple file handles into a single object.

CreateIoCompletionPort函数会使一个I/O完成端口与一个或多个文件句柄发生关联。当与一个完成端口相关的文件句柄上启动的异步I/O操作完成时，一个I/O完成包就会进入到该完成端口的队列中。对于多个文件句柄来说，就可以把这些多个文件句柄合并成一个单独的对象，这个可以被用来结合同步点？

A thread uses the GetQueuedCompletionStatus function to wait for a completion packet to be queued to the completion port, rather than waiting directly for the asynchronous I/O to complete. Threads that block their execution on a completion port are released in last-in-first-out (LIFO) order. This means that when a completion packet is queued to the completion port, the system releases the last thread to block its execution on the port.

调用GetQueuedCompletionStatus函数，某个线程就会等待一个完成包进入到完成端口的队列中，而不是直接等待异步I/O请求完成。线程（们）就会阻塞于它们的运行在完成端口（按照后进先出队列顺序的被释放）。这就意味着当一个完成包进入到完成端口的队列中时，系统会释放最近被阻塞在该完成端口的线程。

When a thread calls GetQueuedCompletionStatus, it is associated with the specified completion port until it exits, specifies a different completion port, or frees the completion port. A thread can be associated with at most one completion port.

调用GetQueuedCompletionStatus，线程就会将会与某个指定的完成端口建立联系，一直延续其该线程的存在周期，或被指定了不同的完成端口，或者释放了与完成端口的联系。一个线程只能与最多不超过一个的完成端口发生联系。

The most important property of a completion port is the concurrency value. The concurrency value of a completion port is specified when the completion port is created. This value limits the number of runnable threads associated with the completion port. When the total number of runnable threads associated with the completion port reaches the concurrency value, the system blocks the execution of any subsequent threads that specify the completion port until the number of runnable threads associated with the completion port drops below the concurrency value. The most efficient scenario occurs when there are completion packets waiting in the queue, but no waits can be satisfied because the port has reached its concurrency limit. In this case, when a running thread calls GetQueuedCompletionStatus, it will immediately pick up the queued completion packet. No context switches will occur, because the running thread is continually picking up completion packets and the other threads are unable to run.

完成端口最重要的特性就是并发量。完成端口的并发量可以在创建该完成端口时指定。该并发量限制了与该完成端口相关联的可运行线程的数目。当与该完成端口相关联的可运行线程的总数目达到了该并发量，系统就会阻塞任何与该完成端口相关联的后续线程的执行，直到与该完成端口相关联的可运行线程数目下降到小于该并发量为止。最有效的假想是发生在有完成包在队列中等待，而没有等待被满足，因为此时完成端口达到了其并发量的极限。此时，一个正在运行中的线程调用GetQueuedCompletionStatus时，它就会立刻从队列中取走该完成包。这样就不存在着环境的切换，因为该处于运行中的线程就会连续不断地从队列中取走完成包，而其他的线程就不能运行了。

The best value to pick for the concurrency value is the number of CPUs on the machine. If your transaction required a lengthy computation, a larger concurrency value will allow more threads to run. Each transaction will take longer to complete, but more transactions will be processed at the same time. It is easy to experiment with the concurrency value to achieve the best effect for your application.

对于并发量最好的挑选值就是您计算机中cpu的数目。如果您的事务处理需要一个漫长的计算时间，一个比较大的并发量可以允许更多线程来运行。虽然完成每个事务处理需要花费更长的时间，但更多的事务可以同时被处理。对于应用程序来说，很容易通过测试并发量来获得最好的效果。

The PostQueuedCompletionStatus function allows an application to queue its own special-purpose I/O completion packets to the completion port without starting an asynchronous I/O operation. This is useful for notifying worker threads of external events.

PostQueuedCompletionStatus函数允许应用程序可以针对自定义的专用I/O完成包进行排队，而无需启动一个异步I/O操作。这点对于通知外部事件的工作者线程来说很有用。

The completion port is freed when there are no more references to it. The completion port handle and every file handle associated with the completion port reference the completion port. All the handles must be closed to free the completion port. To close the port handle, call the CloseHandle function.

在没有更多的引用针对某个完成端口时，需要释放该完成端口。该完成端口句柄以及与该完成端口相关联的所有文件句柄都需要被释放。调用CloseHandle可以释放完成端口的句柄。

TCP状态迁移，CLOSE_WAIT & FIN_WAIT2 的问题

当调用ReadFile()和WriteFile()时，如果最后一个参数lpOverlapped设置为NULL，那么线程就阻塞在这里，直到读写完指定的数据后，它们才返回。这样在读写大文件的时候，很多时间都浪费在等待ReadFile()和WriteFile()的返回上面。如果ReadFile()和WriteFile()是往管道里读写数据，那么有可能阻塞得更久，导致程序性能下降。

为了解决这个问题，Windows引进了重叠I/O的概念，它能够同时以多个线程处理多个I/O。其实你自己开多个线程也可以处理多个I/O，但是系统内部对I/O的处理在性能上有很大的优化。它是Windows下实现异步I/O最常用的方式。

Windows为几乎全部类型的文件提供这个工具：磁盘文件、通信端口、命名管道和套接字。通常，使用ReadFile()和WriteFile()就可以很好地执行重叠I/O。

重叠模型的核心是一个重叠数据结构。若想以重叠方式使用文件，必须用 FILE_FLAG_OVERLAPPED标志打开它，例如：

HANDLE hFile = CreateFile(lpFileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);

如果没有规定该标志，则针对这个文件（句柄）,重叠I/O是不可用的。如果设置了该标志，当调用ReadFile()和WriteFile()操作这个文件（句柄）时，必须为最后一个参数提供OVERLAPPED结构：

// WINBASE.H

typedef struct _OVERLAPPED{

        DWORD   Internal;

        DWORD   InternalHigh;

        DWORD   Offset;

        DWORD   OffsetHigh;

        HANDLE  hEvent; //关键的一个参数

}OVERLAPPED, *LPOVERLAPPED;

头两个32位的结构字Internal和InternalHigh由系统内部使用；其次两个32位结构字Offset和OffsetHigh使得可以设置64位的偏移量，该偏移量是要文件中读或写的地方。

因为I/O异步发生，就不能确定操作是否按顺序完成。因此，这里没有当前位置的概念。对于文件的操作，总是规定该偏移量。在数据流下（如COM端口或socket），没有寻找精确偏移量的方法，所以在这些情况中，系统忽略偏移量。这四个字段不应由应用程序直接进行处理或使用，OVERLAPPED结构的最后一个参数是可选的事件句柄，当I/O完成时，该事件对象受信（signaled）。程序通过等待该对事件对象受信来做善后处理。

设置了OVERLAPPED参数后，ReadFile()/WriteFile()的调用会立即返回，这时候你可以去做其他的事（所谓异步），系统会自动替你完成ReadFile()/WriteFile()相关的I/O操作。你也可以同时发出几个ReadFile()/WriteFile()的调用（所谓重叠）。当系统完成I/O操作时，会将OVERLAPPED.hEvent置信，我们可以通过调用WaitForSingleObject/WaitForMultipleObjects来等待这个I/O完成通知，在得到通知信号后，就可以调用GetOverlappedResult来查询I/O操作的结果，并进行相关处理。由此可以看出，OVERLAPPED结构在一个重叠I/O请求的初始化及其后续的完成之间，提供了一种沟通或通信机制。注意OVERLAPPED结构的生存周期，一般动态分配，待I/O完成后，回收重叠结构。

以Win32重叠I/O机制为基础，自WinSock 2发布开始，重叠I/O便已集成到新的WinSock API中，比如WSARecv()/WSASend()。这样一来，重叠I/O模型便能适用于安装了WinSock 2的所有Windows平台。可以一次投递一个或多个WinSock I/O请求。针对那些提交的请求，在它们完成之后，应用程序可为它们提供服务（对I/O的数据进行处理）。

相应的，要想在一个套接字上使用重叠I/O模型来处理网络数据通信，首先必须使用 WSA_FLAG_OVERLAPPED这个标志来创建一个套接字。如下所示：

SOCKET s = WSASocket(AF_INET, SOCK_STEAM, 0, NULL, 0,  WSA_FLAG_OVERLAPPED);

创建套接字的时候，假如使用的是socket()函数，而非WSASocket()函数，那么会默认设置WSA_FLAG_OVERLAPPED标志。成功创建好了一个套接字，将其与一个本地接口绑定到一起后，便可开始进行这个套接字上的重叠I/O操作，方法是调用下述的WinSock 2函数，同时为它们指定一个WSAOVERLAPPED结构参数（#define WSAOVERLAPPED OVERLAPPED// WINSOCK2.H）：

（1）WSASend()

（2）WSASendTo()

（3）WSARecv()

（4）WSARecvFrom()

（5）WSAIoctl()

（6）AcceptEx()

（7）TransmitFile()

若随一个WSAOVERLAPPED结构一起调用这些函数，函数会立即返回，无论套接字是否设为锁定模式。它们依赖于WSAOVERLAPPED结构来返回一个I/O请求操作的结果。

比起阻塞、select、WSAAsyncSelect以及WSAEventSelect等模型，WinSock的重叠I/O(Overlapped I/O)模型使应用程序能达到更佳的系统性能。因为它和这4种模型不同的是，使用重叠模型的应用程序通知缓冲区收发系统直接使用数据。也就是说，如果应用程序投递了一个10KB大小的缓冲区来接收数据，且数据已经到达套接字，则该数据将直接被拷贝到投递的缓冲区。而这4种模型中，数据到达并拷贝到单套接字接收缓冲区（Per Socket Buffer）中，此时应用程序会被系统通知可以读入的字节数。当应用程序调用接收函数之后，数据才从单套接字缓冲区拷贝到应用程序的缓冲区。这样就减少了一次从I/O缓冲区到应用程序缓冲区的拷贝，差别就在于此。

实际编程时，可以投递一个0字节缓冲区的WSARecv/WSASend操作，这样就没有用户缓冲区与I/O操作相关联，避免了用户缓冲区的锁定（过多的锁定可能导致非分页内存池耗尽，即WSAENOBUFS），应用程序绕开单套接字缓冲区而直接与TCP Stack进行数据交互，从而避免了内存拷贝。当然，只要投递了足够多的重叠发送/接收操作，就能避免额外的内存拷贝，这时将单套接字缓冲区设置为0并不能提升性能。因为应用程序的发送缓冲区将始终被锁定直到可以下传给TCP，所以停用套接字的发送缓冲区对性能的影响比停用接收缓冲区小。然而，如果接收缓冲区被设置为0，而又未投递重叠接收操作，则进来的数据都只能停留在TCP Stack中，而TCP驱动程序的缓冲区最多只能接收窗口大小。TCP缓冲区被定位在非分页内存池中，假如很多连接发数据过来，但我们根本没有投递接收操作，则将消耗大量的非分页内存池。非分页内存池是一种有限的资源，过多的锁定可能导致非分页内存池耗尽，即WSAENOBUFS。

在Windows NT和Windows 2000中，重叠I/O模型也允许应用程序以一种重叠方式实现对套接字连接的处理。具体的做法是在监听套接字上调用AcceptEx函数。AcceptEx是一个特殊的WinSock扩展函数，由mswsock.dll实现，使用时需包含Mswsock.h头文件，链接Mswsock.lib库文件。该函数最初的设计宗旨是在Windows NT与Windows 2000操作系统上使用Win 32的重叠I/O机制。但事实上，它也适用于WinSock 2中的重叠I/O。AcceptEx的定义如下：

// MSWSOCK.H

AcceptEx(

       IN SOCKET sListenSocket,

       IN SOCKET sAcceptSocket,

       IN PVOID lpOutputBuffer,

       IN DWORD dwReceiveDataLength,

       IN DWORD dwLocalAddressLength,

       IN DWORD dwRemoteAddressLength,

       OUT LPDWORD lpdwBytesReceived,

       IN LPOVERLAPPED lpOverlapped);

参数一sListenSocket参数指定的是一个监听套接字。

参数二sAcceptSocket参数指定的是另一个套接字，负责对进入连接请求的“接受”。 AcceptEx()函数和accept()函数的区别在于，我们必须提供接受的套接字，而不是让函数自动为我们创建。正是由于要提供套接字，所以要求我们事先调用socket()或WSASocket()函数创建一个套接字，以便通过sAcceptSocket参数，将其传递给AcceptEx()。

参数三lpOutputBuffer指定的是一个特殊的缓冲区，因为它要负责三种数据的接收：服务器的本地地址，客户机的远程地址，以及在新建连接上接收的第一个数据块。存储顺序是：接收到的数据块→本地地址→远程地址。

参数四dwReceiveDataLength以字节为单位，指定了在lpOutputBuffer缓冲区开头保留多大的空间，用于数据的接收。如这个参数设为0，那么只接受连接，不伴随接收数据。

参数五dwLocalAddressLength和参数六dwRemoteAddressLength也是以字节为单位，指定在lpOutputBuffer缓冲区中，保留多大的空间，在一个套接字被接受的时候，用于本地和远程地址信息的保存。要注意的是，和当前采用的传送协议允许的最大地址长度比较起来，这里指定的缓冲区大小至少应多出16字节。举个例子来说，假定正在使用的是TCP/IP协议，那么这里的大小应设为“SOCKADDR_IN结构的长度＋16字节”。

参数七lpdwBytesReceived参数用于返回接收到的实际数据量，以字节为单位。只有在操作以同步方式完成的前提下，才会设置这个参数。假如AcceptEx()函数返回ERROR_IO_PENDING，那么这个参数永远都不会设置，我们必须利用完成事件通知机制，获知实际读取的字节量。

最后一个参数是lpOverlapped，它对应的是一个OVERLAPPED结构，允许AcceptEx()以一种异步方式工作。如我们早先所述，只有在一个重叠I/O应用中，该函数才需要使用事件对象通知机制（hEvent字段），这是由于此时没有一个完成例程参数可供使用。

二．获取重叠I/O操作完成结果

当异步I/O请求挂起后，最终要知道I/O操作是否完成。一个重叠I/O请求最终完成后，应用程序要负责读取重叠I/O操作的结果。对于读，直到I/O完成，接收缓冲器才有效（参考IRP缓冲区管理）。对于写，要知道写是否成功，有几种方法可以做到这点，最直接的方法是调用(WSA)GetOverlappedResult，其函数原型如下：

WINBASEAPI BOOL WINAPI

GetOverlappedResult(

HANDLE hFile,

LPOVERLAPPED lpOverlapped,

LPDWORD lpNumberOfBytesTransferred,

BOOL bWait);

BOOL WSAAPI WSAGetOverlappedResult(

SOCKET s,

LPWSAOVERLAPPED lpOverlapped,

LPDWORD lpcbTransfer,

BOOL fWait,

LPDWORD lpdwFlags);

参数一为的文件/套接字句柄。

参数二为参数一关联的(WSA) OVERLAPPED结构，在调用CreateFile()、WSASocket()或AcceptEx()时指定。

参数三指向字节计数指针，负责接收一次重叠发送或接收操作实际传输的字节数。

参数四是确定命令是否等待的标志。Wait参数用于决定函数是否应该等待一次重叠操作完成。若将Wait设为TRUE，那么直到操作完成函数才返回；若设为FALSE，而且操作仍然处于未完成状态，那么(WSA)GetOverlappedResult()函数会返回FALSE值。

如(WSA)GetOverlappedResult()函数调用成功，返回值就是TRUE。这意味着我们的重叠I/O操作已成功完成，而且由参数三BytesTransfered参数指向的值已进行了更新。若返回值是FALSE，那么可能是由下述任何一种原因造成的：

■ 重叠I/O操作仍处在“待决”状态。

■ 重叠操作已经完成，但含有错误。

■ 重叠操作的完成状态不可判决，因为在提供给 WSAGetOverlappedResult函数的一个或多个参数中，存在着错误。

失败后，由BytesTransfered参数指向的值不会进行更新，而且我们的应用程序应调用(WSA)GetLastError()函数，检查到底是何种原因造成了调用失败以使用相应容错处理。如果错误码为SOCKET_ERROR/WSA_IO_INCOMPLETE(Overlapped I/O event is not in a signaled state)或SOCKET_ERROR/WSA_IO_PENDING(Overlapped I/O operation is in progress)，则表明I/O仍在进行。当然，这不是真正错误，任何其他错误码则真正表明一个实际错误。

下面介绍两种常用重叠I/O完成通知的方法。

1.使用事件通知

使用(WSA)GetOverlappedResult()是直截了当的，它吻合重叠I/O的概念。毕竟，如果要等待I/O，也许使用常规I/O命令更好。对于大多数程序，反复检查I/O是否完成，并非最佳。解决方案之一是使用(WSA)OVERLAPPED结构中的hEvent字段，使应用程序将一个事件对象句柄同一个文件/套接字关联起来。

当指定OVERLAPPED参数给ReadFile()/WriteFile()或WSARecv()/WSASend()后，可以再为(WSA)OVERLAPPED最后一个参数提供自定义的事件对象（通过(WSA)CreateEvent()创建）。

当I/O完成时，系统更改(WSA)OVERLAPPED结构对应的事件对象的传信状态，使其从“未传信”（unsignaled）变成“已传信”（signaled）。由于我们之前将事件对象分配给了(WSA)OVERLAPPED结构，所以只需简单地调用WaitForSingleObject/WaitForMultipleObjects或WSAWaitForMultipleEvents函数，从而判断出一个（一些）重叠I/O在什么时候完成。通过WaitForSingleObject/WaitForMultipleObjects或WSAWaitForMultipleEvents函数返回的索引可以知道这个重叠I/O完成事件是在哪个HANDLE（File或Socket）上发生的。

然后调用(WSA)GetOverlappedResult()函数，将发生事件的HANDLE（FILE或SOCKET）传给参数一，将这个HANDLE对应的(WSA)OVERLAPPED结构传给参数二，这样判断重叠调用到底是成功还是失败。如果返回FALSE值，则重叠操作已经完成但含有错误。或者重叠操作的完成状态不可判决，因为在提供给(WSA)GetOverlappedResult()函数的一个或多个参数中存在着错误。失败后，由BytesTransfered参数指向的值不会进行更新，应用程序应调用(WSA)GetLastError()函数，调查到底是何种原因造成了调用失败。

若(WSA)GetOverlappedResult()函数返回TRUE，则根据先前调用异步I/O函数时设置的缓冲区(ReadFile/WriteFile或WSARecv/WSASend的lpBuffer字段)和BytesTransfered,使用指针偏移定位就可以准确操作接受到的数据了。

利用事件对象来完成同步通知的方法比重复调用(WSA)GetOverlappedResult()浪费处理器时间的方案要高效得多。但WaitForMultipleObjects/WSAaitForMultipleEvent支持的事件对象个数的上限为MAXIMUM_WAIT_OBJECTS/WSA_MAXIMUM_WAIT_EVENTS=64！

2.使用完成例程

对于文件重叠I/O操作，等待I/O操作结束的另外方法是使用ReadFileEx()和WriteFileEx()。这些命令只用于重叠I/O，当为它们的最后一个参数lpCompletionRoutine传递了一个完成例程指针（回调函数地址）时，I/O操作结束时将调用此函数进行处理。

完成例程指针LPOVERLAPPED_COMPLETION_ROUTINE定义如下：

// WINBASE.H

typedef  VOID (WINAPI *LPOVERLAPPED_COMPLETION_ROUTINE)(

        DWORD dwErrorCode,

        DWORD dwNumberOfBytesTransfered,

        LPOVERLAPPED lpOverlapped );

相应在WinSock 2中，WSARecv()/WSASend()最后一个参数lpCompletionROUTINE是一个可选的指针，它指向一个完成例程。若指定此参数（自定义函数地址），在重叠请求完成后，将调用完成例程处理。完成例程本质上是一种APC（Asynchronous Procedure Calls）。

WinSock 2中完成例程指针LPWSAOVERLAPPED_COMPLETION_ROUTINE定义略有不同：

// WINSOCK2.H

typedef void (CALLBACK * LPWSAOVERLAPPED_COMPLETION_ROUTINE)(

        DWORD dwError,

        DWORD cbTransferred,

        LPWSAOVERLAPPED lpOverlapped,

        DWORD dwFlags );

     前三个参数同LPOVERLAPPED_COMPLETION_ROUTINE，参数四一般不用，置0。用完成例程完成一个重叠I/O请求之后，参数中会包含下述信息：

参数一dwError表明了一个重叠操作（由lpOverlapped指定）的完成状态是什么。

参数二BytesTransferred参数指定了在重叠操作实际传输的字节量是多大。

参数三lpOverlapped参数指定的是调用这个完成例程的异步I/O操作函数(ReadFileEx()/WriteFileEx()或WSARecv()/WSASend())的(WSA)OVERLAPPED结构参数。

提交带有完成例程的重叠I/O请求时，(WSA)OVERLAPPED结构的事件字段hEvent一般不再使用。使用一个含有完成例程指针参数的异步I/O函数发出一个重叠I/O请求之后，一旦重叠I/O操作完成，作为我们的调用线程，必须能够通知完成例程指针所指向的自定义函数开始执行，提供数据处理服务。这样一来，便要求将调用线程置于一种“可警告的等待状态”，在I/O操作完成后，能自动调用完成例程。WSAWaitForMultipleEvents()函数可用来将线程置于一种可警告的等待状态。这样做的代价是必须创建一个事件对象可用于WSAWaitForMultipleEvents()函数。假定应用程序只用完成例程对重叠请求进行处理，便不需要引入事件对象。作为一种变通方法，我们的应用程序可用Win32的SleepEx()函数将自己的线程置为一种可警告的等待状态。当然，亦可创建一个伪事件对象，不将它与任何东西关联在一起。假如调用线程经常处于繁忙状态，而且并不处于一种可警告的等待状态，那么完成例程根本不会被通知执行。

如前面所述，WSAWaitForMultipleEvents()通常会等待同(WSA)OVERLAPPED结构关联在一起的事件对象。该函数也可用于将我们的线程设置为一种可警告的等待状态，为已经完成的重叠I/O请求调用完成例程进行处理（前提是将fAlertable参数设为TRUE）。使用一个含有完成例程指针的异步I/O函数提交了重叠I/O请求之后， WSAWaitForMultipleEvents()的期望返回值是WAIT_IO_COMPLETION（One or more I/O completion routines are queued for execution），而不再是事件对象索引。从宏WAIT_IO_COMPLETION的注解可知，它的意思是有完成例程需要执行。SleepEx()函数的行为实际上和WSAWaitForMultipleEvents()差不多，只是它不需要任何事件对象。对SleepEx函数的定义如下：

WINBASEAPI DWORD WINAPI

SleepEx(

    DWORD dwMilliseconds,

    BOOL bAlertable );

其中，dwMilliseconds参数定义了SleepEx()函数的等待时间，以毫秒为单位。假如将dwMilliseconds设为INFINITE，那么SleepEx()会无休止地等待下去。bAlertable参数规定了一个完成例程的执行方式，若将它设置为FALSE，则使用一个含有完成例程指针的异步I/O函数提交了重叠I/O请求后，I/O完成例程不会被通知执行，而且SleepEx()函数不会返回，除非超过由dwMilliseconds规定的时间；若将它设置为TRUE，则完成例程会被通知执行，同时SleepEx()函数返回WAIT_IO_COMPLETION。

在完成例程处理模型中，投递重叠I/O请求的同时注册完成例程，待I/O完成时由系统回调，并克服了事件通知模型的个数限制。利用完成例程处理重叠I/O的WinSock程序的编写步骤如下：

(1) 新建一个监听套接字，在指定端口上监听客户端的连接请求。

(2) 接受一个客户端的连接请求，并返回一个会话套接字负责与客户端通信。

(3) 为会话套接字关联一个WSAOVERLAPPED结构。

(4) 在套接字上投递一个异步WSARecv请求，方法是将WSAOVERLAPPED指定成为参数，同时提供一个完成例程。

(5) 在将fAlertable参数设为TRUE的前提下，调用WSAWaitForMultipleEvents，并等待一个重叠I/O请求完成。重叠请求完成后，完成例程会自动执行，而且WSAWaitForMultipleEvents会返回一个WAIT_IO_COMPLETION。在完成例程内，可随一个完成例程一道投递另一个重叠WSARecv请求。

(6) 检查WSAWaitForMultipleEvents是否返回WAIT_IO_COMPLETION。

(7) 重复步骤(5)和(6)。

当调用accept处理连接时，一般创建一个AcceptEvent伪事件，当有客户连接时，需要手动SetEvent(AcceptEvent)；当调用AcceptEx处理重叠的连接时，一般为ListenSocket创建一个ListenOverlapped结构，并为其指定一个伪事件，当有客户连接时，系统自动将其置信。这些伪事件的作用在于，当含有完成例程指针的异步I/O操作(如WSARecv)完成时，设置了fAlertable的WSAWaitForMultipleEvents返回WAIT_IO_COMPLETION，并调用完成例程指针指向的完成例程对数据进行处理。

重叠I/O模型的缺点是它一般要为每一个I/O请求都开一个线程，当同时有成千上万个请求发生时，系统处理线程上下文切换是非常耗时的。所以这也就引出了更为先进的完成端口模型IOCP，用线程池来解决这个问题。

参考：

《Windows 2000 Systems Programming Black Book》  Al Williams

《Network Programming for Microsoft Windows》  Anthony Jones,Jim Ohlund

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/phunxm/archive/2009/12/27/5085915.aspx

select模型

select（选择）模型是winsock中常见的I/O模型。之所以称其为“select模型”，是由于它的
“中心思想”是利用select函数，实现对I/O的管理！最初设计该模型时，主要面向的是某些使用
Unix操作系统的计算机，它们采用的是Berkeley套接字方案。select模型已经集成到Winsock1.1中。

1.通过调用select函数可以确定一个或多个套接字的状态，判断套接字上是否有数据，或
者能否向一个套接字写入数据。 
 int select (int nfds,                                                   //忽略
                fd_set FAR *readfds,                                //等待可读性检查的套接字组的地址
                fd_set FAR *writefds,                               //等待可写性检查的套接字组的地址
                fd_set FAR *exceptfds,                              //等待错误检查的套接字组的地址
                const struct timeval FAR *timeout);         //struct timeval结构体地址，select() 最多等待的时间
//返回值       0--超时，SOCKET_ERROR--失败
//说明：此函数的作用是删除fd_set结构体中没有IO操作的套接字
/*注意：在3个套接字组中至少有一个不为NULL；在非空集合中必须包含一个套接字句柄。
     如果timeout设为(0,0)，select() 会立即返回，允许应用程序对select操作进行“轮询”。
     如：
        fd_set fdread;
        FD_ZERO(&fdread);
        FD_SET(s, &fdread);
        select(0, &fdread, NULL, NULL, NULL);
        if(FD_ISSET(s, &fdread))
        {
                //套接字可读
        }
*/


2.管理套接字的结构体
定义：
typedef struct fd_set {
        u_int   fd_count;               /* how many are SET? */  //元素的个数
        SOCKET  fd_array[FD_SETSIZE];   /* an array of SOCKETs */
} fd_set;

对struct fd_set结构体操作的宏
FD_SETSIZE              容量，指定fd_array数组大小，默认为64，也可自己修改宏
FD_ZERO(*set)           置空，使数组的元素值都为3435973836，元素个数为0.
FD_SET(s, *set)         添加，向 struct fd_set结构体添加套接字s
FD_ISSET(s, *set)       判断，判断s是否为 struct fd_set结构体中的一员
FD_CLR(s, *set)         删除，从 struct fd_set结构体中删除成员s    

3.用Select模型获取网络事件

    FD_SET AllSockFd;        //装有所有的套接字
    FD_ZERO(&AllSockFd);
    AllSockFd = ClientSockFd ;
    FD_SET(ListenSock, &AllSockFd);
    FD_SET ReadSockFd;    //读集合
    FD_SET WriteSockFd;    //写集合
    while(1)
    {
        FD_ZERO(&ReadSockFd);
        FD_ZERO(&WriteSockFd);
        ReadSockFd = AllSockFd;
        WriteSockFd = AllSockFd;

        int nRet = select(0, &ReadSockFd, &WriteSockFd, NULL, NULL);    
        if(SOCKET_ERROR == nRet)
        {
            continue;
        }
        //有请求事件发生
        if (FD_ISSET(ListenSock, &ReadSockFd))
        {
            //接受请求
            SOCKET ClientSock;
            u_short Port;
            bool nRe = (*(Pam.pListenSock)).Accept(&ClientSock, 0, &Port);
            if(nRe)
            {
                FD_SET(ClientSock, Pam.pClientSockFd);
                //设置套接字发送缓冲区80K
                int nBuf = SOCKET_BUFF;
                int nBufLen = sizeof(nBuf);
                int nRe = setsockopt(ClientSock, SOL_SOCKET, SO_SNDBUF, (char*)&nBuf, nBufLen);
                if(SOCKET_ERROR == nRe)
                    AfxMessageBox("setsockopt error!");    
                //检查缓冲区是否设置成功
                nRe = getsockopt(ClientSock, SOL_SOCKET, SO_SNDBUF, (char*)&nBuf, &nBufLen);
                if(SOCKET_BUFF != nBuf)
                    AfxMessageBox("检查缓冲区:setsockopt error!");
                else
                    AfxMessageBox("已连接客户端!");
            }
        }
        //判断是否可读或可写
        for(u_int n = 0;n < ClientSockFd.fd_count;n++)
        {
                if(FD_ISSET(ClientSockFd.fd_array[n], &ReadSockFd))        //发现可读
                {        
                        //接收数据
                        //如果失败 删除此元素        
                }
                if(FD_ISSET(ClientSockFd.fd_array[n], &WriteSockFd))    //发现可写  
                {
                        //发送缓冲区未满可以发送
                        //如果失败 删除此元素
                }
        }
    }

转自http://www.cnblogs.com/pen-ink/articles/1834088.html


HANDLE WINAPI CreateIoCompletionPort(
  __in          HANDLE FileHandle,
  __in          HANDLE ExistingCompletionPort,
  __in          ULONG_PTR CompletionKey,
  __in          DWORD NumberOfConcurrentThreads
);
/*
这个函数完成两个不同的任务：1、创建一个完成端口对象；2、将一个或者多个文件句柄关联到I/O完成端口对象。可分成两个小函数对CreateIoCompletionPort调用进行抽象。
*/
//1、创建I/O完成端口
HANDLE CreateNewCompletionPort(DWORD dwNumberOfConcurrentThreads)
{
    return (CreateNewCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, dwNumberOfConcurrentThreads));
}
//2、将设备与I/O完成端口关联起来
BOOL AssociateDeviceWithCompletionPort(HANDLE hCompletionPort, HANDLE hDevice, DWORD dwCompletionKey)
{
    HANDLE h = CreateIoCompletionPort(hDevice, hCompletionPort, dwCompletionKey, 0);
    return (h == hCompletionPort);
}



/////////////////////////////////////////////////
// IOCPDemo.cpp文件            调试通过

#include "WSAInit.h"
#include <stdio.h>
#include <windows.h>

// 初始化Winsock库
CWSAInit theSock;

#define BUFFER_SIZE 1024
#define OP_READ   1
#define OP_WRITE  2
#define OP_ACCEPT 3

typedef struct _PER_HANDLE_DATA        // per-handle数据
{
    SOCKET s;            // 对应的套节字句柄
    sockaddr_in addr;    // 客户方地址
    char buf[BUFFER_SIZE];    // 数据缓冲区
    int nOperationType;        // 操作类型
} PER_HANDLE_DATA, *PPER_HANDLE_DATA;

DWORD WINAPI ServerThread(LPVOID lpParam)
{
    // 得到完成端口对象句柄
    HANDLE hCompletion = (HANDLE)lpParam;

    DWORD dwTrans;
    PPER_HANDLE_DATA pPerHandle;
    OVERLAPPED *pOverlapped;
    while(TRUE)
    {
        // 在关联到此完成端口的所有套节字上等待I/O完成
        BOOL bOK = ::GetQueuedCompletionStatus(hCompletion, 
            &dwTrans, (PULONG_PTR)&pPerHandle, &pOverlapped, WSA_INFINITE);
        if(!bOK)                        // 在此套节字上有错误发生
        {
            ::closesocket(pPerHandle->s);
            ::GlobalFree(pPerHandle);
            ::GlobalFree(pOverlapped);
            continue;
        }

        if(dwTrans == 0 &&                // 套节字被对方关闭
            (pPerHandle->nOperationType == OP_READ || pPerHandle->nOperationType == OP_WRITE))    

        {
            ::closesocket(pPerHandle->s);
            ::GlobalFree(pPerHandle);
            ::GlobalFree(pOverlapped);
            continue;
        }

        switch(pPerHandle->nOperationType)    // 通过per-I/O数据中的nOperationType域查看什么I/O请求完成了
        {
        case OP_READ:    // 完成一个接收请求
            {
                pPerHandle->buf[dwTrans] = '\0';
                printf(pPerHandle-> buf);

                // 继续投递接收I/O请求
                WSABUF buf;
                buf.buf = pPerHandle->buf ;
                buf.len = BUFFER_SIZE;
                pPerHandle->nOperationType = OP_READ;
    
                DWORD nFlags = 0;
                ::WSARecv(pPerHandle->s, &buf, 1, &dwTrans, &nFlags, pOverlapped, NULL);
            }
            break;
        case OP_WRITE: // 本例中没有投递这些类型的I/O请求
        case OP_ACCEPT:
            break;
        }
    }
    return 0;
}


void main()
{
    int nPort = 4567;
    // 创建完成端口对象，创建工作线程处理完成端口对象中事件
    HANDLE hCompletion = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);
    ::CreateThread(NULL, 0, ServerThread, (LPVOID)hCompletion, 0, 0);

    // 创建监听套节字，绑定到本地地址，开始监听
    SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, 0);
    SOCKADDR_IN si;
    si.sin_family = AF_INET;
    si.sin_port = ::ntohs(nPort);
    si.sin_addr.S_un.S_addr = INADDR_ANY;
    ::bind(sListen, (sockaddr*)&si, sizeof(si));
    ::listen(sListen, 5);

    // 循环处理到来的连接
    while(TRUE)
    {
        // 等待接受未决的连接请求
        SOCKADDR_IN saRemote;
        int nRemoteLen = sizeof(saRemote);
        SOCKET sNew = ::accept(sListen, (sockaddr*)&saRemote, &nRemoteLen);
        // 接受到新连接之后，为它创建一个per-handle数据，并将它们关联到完成端口对象。
        PPER_HANDLE_DATA pPerHandle = 
            (PPER_HANDLE_DATA)::GlobalAlloc(GPTR, sizeof(PER_HANDLE_DATA));
        pPerHandle->s = sNew;
        memcpy(&pPerHandle->addr, &saRemote, nRemoteLen);
        pPerHandle->nOperationType = OP_READ;
        ::CreateIoCompletionPort((HANDLE)pPerHandle->s, hCompletion, (ULONG_PTR)pPerHandle, 0);
        // 投递一个接收请求
        OVERLAPPED *pol = (OVERLAPPED *)::GlobalAlloc(GPTR, sizeof(OVERLAPPED));
        WSABUF buf;
        buf.buf = pPerHandle->buf;
        buf.len = BUFFER_SIZE;    
        DWORD dwRecv;
        DWORD dwFlags = 0;
        ::WSARecv(pPerHandle->s, &buf, 1, &dwRecv, &dwFlags, pol, NULL);
    }
}

WINDOWS完成端口编程
   摘要：开发网络程序从来都不是一件容易的事情，尽管只需要遵守很少的一些规则：创建socket，发起连接，接受连接，发送和接收数据，等等。真正的困难在于：让你的程序可以适应从单单一个连接到几千个连接乃至于上万个连接。利用Windows完成端口进行重叠I/O的技术，可以很方便地在Windows平台上开发出支持大量连接的网络服务程序。本文介绍在Windows平台上使用完成端口模型开发的基本原理，同时给出实际的例子。本文主要关注C/S结构的服务器端程序，因为一般来说，开发一个大容量、具有可扩展性的winsock程序就是指服务程序。

1、基本概念
   设备---指windows操作系统上允许通信的任何东西，比如文件、目录、串行口、并行口、邮件槽、命名管道、无名管道、套接字、控制台、逻辑磁盘、物理磁盘等。绝大多数与设备打交道的函数都是CreateFile/ReadFile/WriteFile等，所以我们不能看到**File函数就只想到文件设备。

   与设备通信有两种方式，同步方式和异步方式：同步方式下，当调用ReadFile这类函数时，函数会等待系统执行完所要求的工作，然后才返回；异步方式下，ReadFile这类函数会直接返回，系统自己去完成对设备的操作，然后以某种方式通知完成操作。

   重叠I/O----顾名思义，就是当你调用了某个函数（比如ReadFile）就立刻返回接着做自己的其他动作的时候，系统同时也在对I/0设备进行你所请求的操作，在这段时间内你的程序和系统的内部动作是重叠的，因此有更好的性能。所以，重叠I/O是在异步方式下使用I/O设备的。重叠I/O需要使用的一个非常重要的数据结构：OVERLAPPED。

2、WINDOWS完成端口的特点
   Win32重叠I/O(Overlapped I/O)机制允许发起一个操作，并在操作完成之后接收信息。对于那种需要很长时间才能完成的操作来说，重叠IO机制尤其有用，因为发起重叠操作的线程在重叠请求发出后就可以自由地做别的事情了。在WinNT和Win2000上，提供的真正可扩展的I/O模型就是使用完成端口（Completion Port）的重叠I/O。完成端口---是一种WINDOWS内核对象。完成端口用于异步方式的重叠I/0情况下，当然重叠I/O不一定非得使用完成端口不可，同样设备内核对象、事件对象、告警I/0等也可使用。但是完成端口内部提供了线程池的管理，可以避免反复创建线程的开销，同时可以根据CPU的个数灵活地决定线程个数，而且可以减少线程调度的次数从而提高性能。其实类似于WSAAsyncSelect和select函数的机制更容易兼容Unix，但是难以实现我们想要的“扩展性”。而且windows完成端口机制在操作系统的内部已经作了优化，从而具备了更高的效率。所以，我们选择完成端口开始我们的服务器程序开发。
   1）发起操作不一定完成：系统会在完成的时候通知你，通过用户在完成端口上的等待，处理操作的结果。所以要有检查完成端口和取操作结果的线程。在完成端口上守候的线程系统有优化，除非在执行的线程发生阻塞，不会有新的线程被激活，以此来减少线程切换造成的性能代价。所以如果程序中没有太多的阻塞操作，就没有必要启动太多的线程，使用CPU数量的两倍，一般这么多线程就够了。
   2）操作与相关数据的绑定方式：在提交数据的时候用户对数据打上相应的标记，记录操作的类型，在用户处理操作结果的时候，通过检查自己打的标记和系统的操作结果进行相应的处理。
   3）操作返回的方式：一般操作完成后要通知程序进行后续处理。但写操作可以不通知用户，此时如果用户写操作不能马上完成，写操作的相关数据会被暂存到非交换缓冲区中，在操作完成的时候，系统会自动释放缓冲区，此时发起完写操作，使用的内存就可以释放了。但如果占用非交换缓冲太多会使系统停止响应。

3、完成端口（Completion Ports ）相关数据结构和创建
    其实可以把完成端口看成系统维护的一个队列，操作系统把重叠IO操作完成的事件通知放到该队列里，由于是暴露 “操作完成”的事件通知，所以命名为“完成端口”（Completion Ports）。一个socket被创建后，就可以在任何时刻和一个完成端口联系起来。

OVERLAPPED数据结构
typedef struct _OVERLAPPED {
    ULONG_PTR Internal;  //被系统内部赋值，用来表示系统状态
    ULONG_PTR InternalHigh;  //被系统内部赋值，表示传输的字节数
    union {
        struct {
            DWORD Offset;  //与OffsetHigh合成一个64位的整数，用来表示从文件头部的多少字节开始操作 
            DWORD OffsetHigh;  //如果不是对文件I/O来操作，则Offset必须设定为0 
         }; 
       PVOID Pointer;
    }; 
   HANDLE hEvent;  //如果不使用，就务必设为0；否则请赋一个有效的Event句柄
} OVERLAPPED, *LPOVERLAPPED;

下面是异步方式使用ReadFile的一个例子
OVERLAPPED Overlapped;
Overlapped.Offset=345;
Overlapped.OffsetHigh=0;
Overlapped.hEvent=0;
//假定其他参数都已经被初始化
ReadFile(hFile,buffer,sizeof(buffer),&dwNumBytesRead,&Overlapped);
这样就完成了异步方式读文件的操作，然后ReadFile函数返回，由操作系统做自己的事情。

下面介绍几个与OVERLAPPED结构相关的函数。

等待重叠I/0操作完成的函数
BOOL GetOverlappedResult (
HANDLE hFile,
LPOVERLAPPED lpOverlapped, //接受返回的重叠I/0结构
LPDWORD lpcbTransfer, //成功传输了多少字节数
BOOL fWait  //TRUE只有当操作完成才返回，FALSE直接返回，如果操作没有完成，
                    //通过用GetLastError( )函数会返回ERROR_IO_INCOMPLETE
);

而宏HasOverlappedIoCompleted可以帮助我们测试重叠I/0操作是否完成，该宏对OVERLAPPED结构的Internal成员进行了测试，查看是否等于STATUS_PENDING值。

   一般来说，一个应用程序可以创建多个工作线程来处理完成端口上的通知事件。工作线程的数量依赖于程序的具体需要。但是在理想的情况下，应该对应一个CPU 创建一个线程。因为在完成端口理想模型中，每个线程都可以从系统获得一个“原子”性的时间片，轮番运行并检查完成端口，线程的切换是额外的开销。但在实际开发的时候，还要考虑这些线程是否牵涉到其他堵塞操作的情况。如果某线程进行堵塞操作，系统则将其挂起，让别的线程获得运行时间。因此，如果有这样的情况，可以多创建几个线程来尽量利用时间。

创建完成端口的函数
完成端口是一个内核对象，使用时它总是要和至少一个有效的设备句柄相关联，完成端口是一个复杂的内核对象，创建它的函数是：
HANDLE CreateIoCompletionPort(
    IN HANDLE FileHandle,
    IN HANDLE ExistingCompletionPort,
    IN ULONG_PTR CompletionKey,
    IN DWORD NumberOfConcurrentThreads
    );

通常创建工作分两步：
第一步，创建一个新的完成端口内核对象，可以使用下面的函数：
       HANDLE CreateNewCompletionPort(DWORD dwNumberOfThreads)
       {    
          return CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,NULL,dwNumberOfThreads);
       };      
第二步，将刚创建的完成端口和一个有效的设备句柄关联起来，可以使用下面的函数：
       bool AssicoateDeviceWithCompletionPort(HANDLE hCompPort,HANDLE hDevice,DWORD dwCompKey)
       {
          HANDLE h=CreateIoCompletionPort(hDevice,hCompPort,dwCompKey,0);
          return h==hCompPort;
       };
说明如下：
1）CreateIoCompletionPort函数也可以一次性的既创建完成端口对象，又关联到一个有效的设备句柄。
2）CompletionKey是一个可以自己定义的参数，我们可以把一个结构的地址赋给它，然后在合适的时候取出来使用，最好要保证结构里面的内存不是分配在栈上，除非你有十分的把握内存会保留到你要使用的那一刻。
3）NumberOfConcurrentThreads用来指定要允许同时运行的的线程的最大个数，通常我们指定为0，这样系统会根据CPU的个数来自动确定。
4）创建和关联的动作完成后，系统会将完成端口关联的设备句柄、完成键作为一条纪录加入到这个完成端口的设备列表中。如果你有多个完成端口，就会有多个对应的设备列表。如果设备句柄被关闭，则表中该纪录会被自动删除。

4、完成端口线程的工作原理

1）完成端口管理线程池
   完成端口可以帮助我们管理线程池，但是线程池中的线程需要我们自己使用_beginthreadex来创建，凭什么通知完成端口管理我们的新线程呢？答案在函数GetQueuedCompletionStatus。该函数原型：
BOOL GetQueuedCompletionStatus(
    IN HANDLE CompletionPort,
    OUT LPDWORD lpNumberOfBytesTransferred,
    OUT PULONG_PTR lpCompletionKey,
    OUT LPOVERLAPPED *lpOverlapped,
    IN DWORD dwMilliseconds
); 

   这个函数试图从指定的完成端口的I/0完成队列中提取纪录。只有当重叠I/O动作完成的时候，完成队列中才有纪录。凡是调用这个函数的线程将会被放入到完成端口的等待线程队列中，因此完成端口就可以在自己的线程池中帮助我们维护这个线程。完成端口的I/0完成队列中存放了当重叠I/0完成的结果---- 一条纪录，该纪录拥有四个字段，前三项就对应GetQueuedCompletionStatus函数的2、3、4参数，最后一个字段是错误信息dwError。我们也可以通过调用PostQueudCompletionStatus模拟完成一个重叠I/0操作。 

   当I/0完成队列中出现了纪录，完成端口将会检查等待线程队列，该队列中的线程都是通过调用GetQueuedCompletionStatus函数使自己加入队列的。等待线程队列很简单，只是保存了这些线程的ID。完成端口按照后进先出的原则将一个线程队列的ID放入到释放线程列表中，同时该线程将从等待GetQueuedCompletionStatus函数返回的睡眠状态中变为可调度状态等待CPU的调度。所以我们的线程要想成为完成端口管理的线程，就必须要调用GetQueuedCompletionStatus函数。出于性能的优化，实际上完成端口还维护了一个暂停线程列表，具体细节可以参考《Windows高级编程指南》，我们现在知道的知识，已经足够了。

2）线程间数据传递
   完成端口线程间传递数据最常用的办法是在_beginthreadex函数中将参数传递给线程函数，或者使用全局变量。但完成端口也有自己的传递数据的方法，答案就在于CompletionKey和OVERLAPPED参数。
CompletionKey被保存在完成端口的设备表中，是和设备句柄一一对应的，我们可以将与设备句柄相关的数据保存到CompletionKey中，或者将CompletionKey表示为结构指针，这样就可以传递更加丰富的内容。这些内容只能在一开始关联完成端口和设备句柄的时候做，因此不能在以后动态改变。

   OVERLAPPED参数是在每次调用ReadFile这样的支持重叠I/0的函数时传递给完成端口的。我们可以看到，如果我们不是对文件设备做操作，该结构的成员变量就对我们几乎毫无作用。我们需要附加信息，可以创建自己的结构，然后将OVERLAPPED结构变量作为我们结构变量的第一个成员，然后传递第一个成员变量的地址给ReadFile这样的函数。因为类型匹配，当然可以通过编译。当GetQueuedCompletionStatus函数返回时，我们可以获取到第一个成员变量的地址，然后一个简单的强制转换，我们就可以把它当作完整的自定义结构的指针使用，这样就可以传递很多附加的数据了。太好了！只有一点要注意，如果跨线程传递，请注意将数据分配到堆上，并且接收端应该将数据用完后释放。我们通常需要将ReadFile这样的异步函数的所需要的缓冲区放到我们自定义的结构中，这样当GetQueuedCompletionStatus被返回时，我们的自定义结构的缓冲区变量中就存放了I/0操作的数据。CompletionKey和OVERLAPPED参数，都可以通过GetQueuedCompletionStatus函数获得。

3）线程的安全退出
   很多线程为了不止一次地执行异步数据处理，需要使用如下语句
while (true)
{
       ......
       GetQueuedCompletionStatus(...); 
       ......
}
那么线程如何退出呢，答案就在于上面曾提到过的PostQueudCompletionStatus函数，我们可以向它发送一个自定义的包含了OVERLAPPED成员变量的结构地址，里面含一个状态变量，当状态变量为退出标志时，线程就执行清除动作然后退出。

5、Windows完成端口的实例代码
DWORD WINAPI WorkerThread(LPVOID lpParam)
{
ULONG_PTR *PerHandleKey;
OVERLAPPED *Overlap;
OVERLAPPEDPLUS *OverlapPlus;
OVERLAPPEDPLUS *newolp;
DWORD dwBytesXfered;
while (1)
{
  ret = GetQueuedCompletionStatus(hIocp, &dwBytesXfered, (PULONG_PTR)&PerHandleKey, &Overlap, INFINITE);
  if (ret == 0)
   {
    // Operation failed
    continue;
   }
 OverlapPlus = CONTAINING_RECORD(Overlap, OVERLAPPEDPLUS, ol);
 switch (OverlapPlus->OpCode)
 {
 case OP_ACCEPT:
   // Client socket is contained in OverlapPlus.sclient
   // Add client to completion port
  CreateIoCompletionPort((HANDLE)OverlapPlus->sclient, hIocp, (ULONG_PTR)0, 0);
  // Need a new OVERLAPPEDPLUS structure
  // for the newly accepted socket. Perhaps
  // keep a look aside list of free structures.
  newolp = AllocateOverlappedPlus();
  if (!newolp)
   {
    // Error
   }
  newolp->s = OverlapPlus->sclient;
  newolp->OpCode = OP_READ;
  // This function divpares the data to be sent
  PrepareSendBuffer(&newolp->wbuf);
  ret = WSASend(newolp->s, &newolp->wbuf, 1, &newolp->dwBytes, 0, &newolp.ol, NULL);
  if (ret == SOCKET_ERROR)
   {
    if (WSAGetLastError() != WSA_IO_PENDING)
     {
       // Error
     }
   }
  // Put structure in look aside list for later use
  FreeOverlappedPlus(OverlapPlus);
  // Signal accept thread to issue another AcceptEx
  SetEvent(hAcceptThread);
  break;
case OP_READ:
  // Process the data read
  // Repost the read if necessary, reusing the same
  // receive buffer as before
  memset(&OverlapPlus->ol, 0, sizeof(OVERLAPPED));
  ret = WSARecv(OverlapPlus->s, &OverlapPlus->wbuf, 1, &OverlapPlus->dwBytes, &OverlapPlus->dwFlags, &OverlapPlus->ol, NULL);
  if (ret == SOCKET_ERROR)
  {
    if (WSAGetLastError() != WSA_IO_PENDING)
     {
      // Error
     }
  }
  break;
case OP_WRITE:
  // Process the data sent, etc.
  break;
} // switch
} // while
} // WorkerThread
　

查看以上代码，注意如果Overlapped操作立刻失败（比如，返回SOCKET_ERROR或其他非WSA_IO_PENDING的错误），则没有任何完成通知时间会被放到完成端口队列里。反之，则一定有相应的通知时间被放到完成端口队列。更完善的关于Winsock的完成端口机制，可以参考 MSDN的Microsoft PlatForm SDK，那里有完成端口的例子。

HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。它于1990年提出，经过几年的使用与发展，得到不断地完善和扩展。目前在WWW中使用的是HTTP/1.0的第六版，HTTP/1.1的规范化工作正在进行之中，而且HTTP-NG(Next Generation of HTTP)的建议已经提出。
HTTP协议的主要特点可概括如下：
1.支持客户/服务器模式。
2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。
3.灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。
4.无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。
5.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

一、HTTP协议详解之URL篇

    http（超文本传输协议）是一个基于请求与响应模式的、无状态的、应用层的协议，常基于TCP的连接方式，HTTP1.1版本中给出一种持续连接的机制，绝大多数的Web开发，都是构建在HTTP协议之上的Web应用。

HTTP URL (URL是一种特殊类型的URI，包含了用于查找某个资源的足够的信息)的格式如下：
http://host[":"port][abs_path]
http表示要通过HTTP协议来定位网络资源；host表示合法的Internet主机域名或者IP地址；port指定一个端口号，为空则使用缺省端口80；abs_path指定请求资源的URI；如果URL中没有给出abs_path，那么当它作为请求URI时，必须以“/”的形式给出，通常这个工作浏览器自动帮我们完成。
eg:
1、输入：www.guet.edu.cn
浏览器自动转换成：http://www.guet.edu.cn/
2、http:192.168.0.116:8080/index.jsp

二、HTTP协议详解之请求篇

    http请求由三部分组成，分别是：请求行、消息报头、请求正文

1、请求行以一个方法符号开头，以空格分开，后面跟着请求的URI和协议的版本，格式如下：Method Request-URI HTTP-Version CRLF 
其中 Method表示请求方法；Request-URI是一个统一资源标识符；HTTP-Version表示请求的HTTP协议版本；CRLF表示回车和换行（除了作为结尾的CRLF外，不允许出现单独的CR或LF字符）。

请求方法（所有方法全为大写）有多种，各个方法的解释如下：
GET     请求获取Request-URI所标识的资源
POST    在Request-URI所标识的资源后附加新的数据
HEAD    请求获取由Request-URI所标识的资源的响应消息报头
PUT     请求服务器存储一个资源，并用Request-URI作为其标识
DELETE  请求服务器删除Request-URI所标识的资源
TRACE   请求服务器回送收到的请求信息，主要用于测试或诊断
CONNECT 保留将来使用
OPTIONS 请求查询服务器的性能，或者查询与资源相关的选项和需求
应用举例：
GET方法：在浏览器的地址栏中输入网址的方式访问网页时，浏览器采用GET方法向服务器获取资源，eg:GET /form.html HTTP/1.1 (CRLF)

POST方法要求被请求服务器接受附在请求后面的数据，常用于提交表单。
eg：POST /reg.jsp HTTP/ (CRLF)
Accept:image/gif,image/x-xbit,... (CRLF)
...
HOST:www.guet.edu.cn (CRLF)
Content-Length:22 (CRLF)
Connection:Keep-Alive (CRLF)
Cache-Control:no-cache (CRLF)
(CRLF)         //该CRLF表示消息报头已经结束，在此之前为消息报头
user=jeffrey&pwd=1234  //此行以下为提交的数据

HEAD方法与GET方法几乎是一样的，对于HEAD请求的回应部分来说，它的HTTP头部中包含的信息与通过GET请求所得到的信息是相同的。利用这个方法，不必传输整个资源内容，就可以得到Request-URI所标识的资源的信息。该方法常用于测试超链接的有效性，是否可以访问，以及最近是否更新。
2、请求报头后述
3、请求正文(略)

三、HTTP协议详解之响应篇

    在接收和解释请求消息后，服务器返回一个HTTP响应消息。

HTTP响应也是由三个部分组成，分别是：状态行、消息报头、响应正文
1、状态行格式如下：
HTTP-Version Status-Code Reason-Phrase CRLF
其中，HTTP-Version表示服务器HTTP协议的版本；Status-Code表示服务器发回的响应状态代码；Reason-Phrase表示状态代码的文本描述。
状态代码有三位数字组成，第一个数字定义了响应的类别，且有五种可能取值：
1xx：指示信息--表示请求已接收，继续处理
2xx：成功--表示请求已被成功接收、理解、接受
3xx：重定向--要完成请求必须进行更进一步的操作
4xx：客户端错误--请求有语法错误或请求无法实现
5xx：服务器端错误--服务器未能实现合法的请求
常见状态代码、状态描述、说明：
200 OK      //客户端请求成功
400 Bad Request  //客户端请求有语法错误，不能被服务器所理解
401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报                 //头域一起使用
403 Forbidden  //服务器收到请求，但是拒绝提供服务
404 Not Found  //请求资源不存在，eg：输入了错误的URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable  //服务器当前不能处理客户端的请求，一段时间后，                         //可能恢复正常
eg：HTTP/1.1 200 OK （CRLF）

2、响应报头后述

3、响应正文就是服务器返回的资源的内容

四、HTTP协议详解之消息报头篇

    HTTP消息由客户端到服务器的请求和服务器到客户端的响应组成。请求消息和响应消息都是由开始行（对于请求消息，开始行就是请求行，对于响应消息，开始行就是状态行），消息报头（可选），空行（只有CRLF的行），消息正文（可选）组成。

HTTP消息报头包括普通报头、请求报头、响应报头、实体报头。
每一个报头域都是由名字+“：”+空格+值 组成，消息报头域的名字是大小写无关的。

1、普通报头
在普通报头中，有少数报头域用于所有的请求和响应消息，但并不用于被传输的实体，只用于传输的消息。
eg：
Cache-Control   用于指定缓存指令，缓存指令是单向的（响应中出现的缓存指令在请求中未必会出现），且是独立的（一个消息的缓存指令不会影响另一个消息处理的缓存机制），HTTP1.0使用的类似的报头域为Pragma。
请求时的缓存指令包括：no-cache（用于指示请求或响应消息不能缓存）、no-store、max-age、max-stale、min-fresh、only-if-cached;
响应时的缓存指令包括：public、private、no-cache、no-store、no-transform、must-revalidate、proxy-revalidate、max-age、s-maxage.
eg：为了指示IE浏览器（客户端）不要缓存页面，服务器端的JSP程序可以编写如下：response.sehHeader("Cache-Control","no-cache");
//response.setHeader("Pragma","no-cache");作用相当于上述代码，通常两者//合用
这句代码将在发送的响应消息中设置普通报头域：Cache-Control:no-cache

Date普通报头域表示消息产生的日期和时间

Connection普通报头域允许发送指定连接的选项。例如指定连接是连续，或者指定“close”选项，通知服务器，在响应完成后，关闭连接

2、请求报头
请求报头允许客户端向服务器端传递请求的附加信息以及客户端自身的信息。
常用的请求报头
Accept
Accept请求报头域用于指定客户端接受哪些类型的信息。eg：Accept：image/gif，表明客户端希望接受GIF图象格式的资源；Accept：text/html，表明客户端希望接受html文本。
Accept-Charset
Accept-Charset请求报头域用于指定客户端接受的字符集。eg：Accept-Charset:iso-8859-1,gb2312.如果在请求消息中没有设置这个域，缺省是任何字符集都可以接受。
Accept-Encoding
Accept-Encoding请求报头域类似于Accept，但是它是用于指定可接受的内容编码。eg：Accept-Encoding:gzip.deflate.如果请求消息中没有设置这个域服务器假定客户端对各种内容编码都可以接受。
Accept-Language
Accept-Language请求报头域类似于Accept，但是它是用于指定一种自然语言。eg：Accept-Language:zh-cn.如果请求消息中没有设置这个报头域，服务器假定客户端对各种语言都可以接受。
Authorization
Authorization请求报头域主要用于证明客户端有权查看某个资源。当浏览器访问一个页面时，如果收到服务器的响应代码为401（未授权），可以发送一个包含Authorization请求报头域的请求，要求服务器对其进行验证。
Host（发送请求时，该报头域是必需的）
Host请求报头域主要用于指定被请求资源的Internet主机和端口号，它通常从HTTP URL中提取出来的，eg：
我们在浏览器中输入：http://www.guet.edu.cn/index.html
浏览器发送的请求消息中，就会包含Host请求报头域，如下：
Host：www.guet.edu.cn
此处使用缺省端口号80，若指定了端口号，则变成：Host：www.guet.edu.cn:指定端口号
User-Agent
我们上网登陆论坛的时候，往往会看到一些欢迎信息，其中列出了你的操作系统的名称和版本，你所使用的浏览器的名称和版本，这往往让很多人感到很神奇，实际上，服务器应用程序就是从User-Agent这个请求报头域中获取到这些信息。User-Agent请求报头域允许客户端将它的操作系统、浏览器和其它属性告诉服务器。不过，这个报头域不是必需的，如果我们自己编写一个浏览器，不使用User-Agent请求报头域，那么服务器端就无法得知我们的信息了。
请求报头举例：
GET /form.html HTTP/1.1 (CRLF)
Accept:image/gif,image/x-xbitmap,image/jpeg,application/x-shockwave-flash,application/vnd.ms-excel,application/vnd.ms-powerpoint,application/msword,*/* (CRLF)
Accept-Language:zh-cn (CRLF)
Accept-Encoding:gzip,deflate (CRLF)
If-Modified-Since:Wed,05 Jan 2007 11:21:25 GMT (CRLF)
If-None-Match:W/"80b1a4c018f3c41:8317" (CRLF)
User-Agent:Mozilla/4.0(compatible;MSIE6.0;Windows NT 5.0) (CRLF)
Host:www.guet.edu.cn (CRLF)
Connection:Keep-Alive (CRLF)
(CRLF)

3、响应报头
响应报头允许服务器传递不能放在状态行中的附加响应信息，以及关于服务器的信息和对Request-URI所标识的资源进行下一步访问的信息。
常用的响应报头
Location
Location响应报头域用于重定向接受者到一个新的位置。Location响应报头域常用在更换域名的时候。
Server
Server响应报头域包含了服务器用来处理请求的软件信息。与User-Agent请求报头域是相对应的。下面是
Server响应报头域的一个例子：
Server：Apache-Coyote/1.1
WWW-Authenticate
WWW-Authenticate响应报头域必须被包含在401（未授权的）响应消息中，客户端收到401响应消息时候，并发送Authorization报头域请求服务器对其进行验证时，服务端响应报头就包含该报头域。
eg：WWW-Authenticate:Basic realm="Basic Auth Test!"  //可以看出服务器对请求资源采用的是基本验证机制。

4、实体报头
请求和响应消息都可以传送一个实体。一个实体由实体报头域和实体正文组成，但并不是说实体报头域和实体正文要在一起发送，可以只发送实体报头域。实体报头定义了关于实体正文（eg：有无实体正文）和请求所标识的资源的元信息。
常用的实体报头
Content-Encoding
Content-Encoding实体报头域被用作媒体类型的修饰符，它的值指示了已经被应用到实体正文的附加内容的编码，因而要获得Content-Type报头域中所引用的媒体类型，必须采用相应的解码机制。Content-Encoding这样用于记录文档的压缩方法，eg：Content-Encoding：gzip
Content-Language
Content-Language实体报头域描述了资源所用的自然语言。没有设置该域则认为实体内容将提供给所有的语言阅读
者。eg：Content-Language:da
Content-Length
Content-Length实体报头域用于指明实体正文的长度，以字节方式存储的十进制数字来表示。
Content-Type
Content-Type实体报头域用语指明发送给接收者的实体正文的媒体类型。eg：
Content-Type:text/html;charset=ISO-8859-1
Content-Type:text/html;charset=GB2312
Last-Modified
Last-Modified实体报头域用于指示资源的最后修改日期和时间。
Expires
Expires实体报头域给出响应过期的日期和时间。为了让代理服务器或浏览器在一段时间以后更新缓存中(再次访问曾访问过的页面时，直接从缓存中加载，缩短响应时间和降低服务器负载)的页面，我们可以使用Expires实体报头域指定页面过期的时间。eg：Expires：Thu，15 Sep 2006 16:23:12 GMT
HTTP1.1的客户端和缓存必须将其他非法的日期格式（包括0）看作已经过期。eg：为了让浏览器不要缓存页面，我们也可以利用Expires实体报头域，设置为0，jsp中程序如下：response.setDateHeader("Expires","0");

五、利用telnet观察http协议的通讯过程

    实验目的及原理：
    利用MS的telnet工具，通过手动输入http请求信息的方式，向服务器发出请求，服务器接收、解释和接受请求后，会返回一个响应，该响应会在telnet窗口上显示出来，从而从感性上加深对http协议的通讯过程的认识。

    实验步骤：

1、打开telnet
1.1 打开telnet
运行-->cmd-->telnet

1.2 打开telnet回显功能
set localecho

2、连接服务器并发送请求
2.1 open www.guet.edu.cn 80  //注意端口号不能省略

    HEAD /index.asp HTTP/1.0
    Host:www.guet.edu.cn
   
   /*我们可以变换请求方法,请求桂林电子主页内容,输入消息如下*/
    open www.guet.edu.cn 80
  
    GET /index.asp HTTP/1.0  //请求资源的内容
    Host:www.guet.edu.cn  

2.2 open www.sina.com.cn 80  //在命令提示符号下直接输入telnet www.sina.com.cn 80
    HEAD /index.asp HTTP/1.0
    Host:www.sina.com.cn
 

3 实验结果：

3.1 请求信息2.1得到的响应是:

HTTP/1.1 200 OK                                              //请求成功
Server: Microsoft-IIS/5.0                                    //web服务器
Date: Thu,08 Mar 200707:17:51 GMT
Connection: Keep-Alive                                
Content-Length: 23330
Content-Type: text/html
Expries: Thu,08 Mar 2007 07:16:51 GMT
Set-Cookie: ASPSESSIONIDQAQBQQQB=BEJCDGKADEDJKLKKAJEOIMMH; path=/
Cache-control: private

//资源内容省略

3.2 请求信息2.2得到的响应是:

HTTP/1.0 404 Not Found       //请求失败
Date: Thu, 08 Mar 2007 07:50:50 GMT
Server: Apache/2.0.54 <Unix>
Last-Modified: Thu, 30 Nov 2006 11:35:41 GMT
ETag: "6277a-415-e7c76980"
Accept-Ranges: bytes
X-Powered-By: mod_xlayout_jh/0.0.1vhs.markII.remix
Vary: Accept-Encoding
Content-Type: text/html
X-Cache: MISS from zjm152-78.sina.com.cn
Via: 1.0 zjm152-78.sina.com.cn:80<squid/2.6.STABLES-20061207>
X-Cache: MISS from th-143.sina.com.cn
Connection: close

失去了跟主机的连接

按任意键继续...

4 .注意事项：1、出现输入错误，则请求不会成功。
          2、报头域不分大小写。
          3、更深一步了解HTTP协议，可以查看RFC2616，在http://www.letf.org/rfc上找到该文件。
          4、开发后台程序必须掌握http协议

六、HTTP协议相关技术补充

    1、基础：
    高层协议有：文件传输协议FTP、电子邮件传输协议SMTP、域名系统服务DNS、网络新闻传输协议NNTP和HTTP协议等
中介由三种：代理(Proxy)、网关(Gateway)和通道(Tunnel)，一个代理根据URI的绝对格式来接受请求，重写全部或部分消息，通过 URI的标识把已格式化过的请求发送到服务器。网关是一个接收代理，作为一些其它服务器的上层，并且如果必须的话，可以把请求翻译给下层的服务器协议。一 个通道作为不改变消息的两个连接之间的中继点。当通讯需要通过一个中介(例如：防火墙等)或者是中介不能识别消息的内容时，通道经常被使用。
     代理(Proxy)：一个中间程序，它可以充当一个服务器，也可以充当一个客户机，为其它客户机建立请求。请求是通过可能的翻译在内部或经过传递到其它的 服务器中。一个代理在发送请求信息之前，必须解释并且如果可能重写它。代理经常作为通过防火墙的客户机端的门户，代理还可以作为一个帮助应用来通过协议处 理没有被用户代理完成的请求。
网关(Gateway)：一个作为其它服务器中间媒介的服务器。与代理不同的是，网关接受请求就好象对被请求的资源来说它就是源服务器；发出请求的客户机并没有意识到它在同网关打交道。
　　网关经常作为通过防火墙的服务器端的门户，网关还可以作为一个协议翻译器以便存取那些存储在非HTTP系统中的资源。
    通道(Tunnel)：是作为两个连接中继的中介程序。一旦激活，通道便被认为不属于HTTP通讯，尽管通道可能是被一个HTTP请求初始化的。当被中继 的连接两端关闭时，通道便消失。当一个门户(Portal)必须存在或中介(Intermediary)不能解释中继的通讯时通道被经常使用。

2、协议分析的优势—HTTP分析器检测网络攻击
以模块化的方式对高层协议进行分析处理，将是未来入侵检测的方向。
HTTP及其代理的常用端口80、3128和8080在network部分用port标签进行了规定

3、HTTP协议Content Lenth限制漏洞导致拒绝服务攻击
使用POST方法时，可以设置ContentLenth来定义需要传送的数据长度，例如ContentLenth:999999999，在传送完成前，内 存不会释放，攻击者可以利用这个缺陷，连续向WEB服务器发送垃圾数据直至WEB服务器内存耗尽。这种攻击方法基本不会留下痕迹。
http://www.cnpaf.net/Class/HTTP/0532918532667330.html

4、利用HTTP协议的特性进行拒绝服务攻击的一些构思
服务器端忙于处理攻击者伪造的TCP连接请求而无暇理睬客户的正常请求（毕竟客户端的正常请求比率非常之小），此时从正常客户的角度看来，服务器失去响应，这种情况我们称作：服务器端受到了SYNFlood攻击（SYN洪水攻击）。
而Smurf、TearDrop等是利用ICMP报文来Flood和IP碎片攻击的。本文用“正常连接”的方法来产生拒绝服务攻击。
19端口在早期已经有人用来做Chargen攻击了，即Chargen_Denial_of_Service，但是！他们用的方法是在两台Chargen 服务器之间产生UDP连接，让服务器处理过多信息而DOWN掉，那么，干掉一台WEB服务器的条件就必须有2个：1.有Chargen服务2.有HTTP 服务
方法：攻击者伪造源IP给N台Chargen发送连接请求（Connect），Chargen接收到连接后就会返回每秒72字节的字符流（实际上根据网络实际情况，这个速度更快）给服务器。

5、Http指纹识别技术
   Http指纹识别的原理大致上也是相同的：记录不同服务器对Http协议执行中的微小差别进行识别.Http指纹识别比TCP/IP堆栈指纹识别复杂许 多,理由是定制Http服务器的配置文件、增加插件或组件使得更改Http的响应信息变的很容易,这样使得识别变的困难；然而定制TCP/IP堆栈的行为 需要对核心层进行修改,所以就容易识别.
      要让服务器返回不同的Banner信息的设置是很简单的,象Apache这样的开放源代码的Http服务器,用户可以在源代码里修改Banner信息,然 后重起Http服务就生效了；对于没有公开源代码的Http服务器比如微软的IIS或者是Netscape,可以在存放Banner信息的Dll文件中修 改,相关的文章有讨论的,这里不再赘述,当然这样的修改的效果还是不错的.另外一种模糊Banner信息的方法是使用插件。
常用测试请求：
1：HEAD/Http/1.0发送基本的Http请求
2：DELETE/Http/1.0发送那些不被允许的请求,比如Delete请求
3：GET/Http/3.0发送一个非法版本的Http协议请求
4：GET/JUNK/1.0发送一个不正确规格的Http协议请求
Http指纹识别工具Httprint,它通过运用统计学原理,组合模糊的逻辑学技术,能很有效的确定Http服务器的类型.它可以被用来收集和分析不同Http服务器产生的签名。

6、其他：为了提高用户使用浏览器时的性能，现代浏览器还支持并发的访问方式，浏览一个网页时同时建立多个连接，以迅速获得一个网页上的多个图标，这样能更快速完成整个网页的传输。
HTTP1.1中提供了这种持续连接的方式，而下一代HTTP协议：HTTP-NG更增加了有关会话控制、丰富的内容协商等方式的支持，来提供
更高效率的连接。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/gueter/archive/2007/03/08/1524447.aspx

 

• 第一次握手:
  客户端发送一个TCP的SYN标志位置1的包指明客户打算连接的服务器的端口，以及初始序号X,保存在包头的序列号(Sequence Number)字段里。

• 第二次握手:
  服务器发回确认包(ACK)应答。即SYN标志位和ACK标志位均为1同时，将确认序号(Acknowledgement Number)设置为客户的I S N加1以.即X+1。

• 第三次握手.
  客户端再次发送确认包(ACK) SYN标志位为0,ACK标志位为1.并且把服务器发来ACK的序号字段+1,放在确定字段中发送给对方.并且在数据段放写ISN的+1

SYN攻击

   在三次握手过程中，服务器发送SYN-ACK之后，收到客户端的ACK之前的TCP连接称为半连接(half-open connect).此时服务器处于Syn_RECV状态.当收到ACK后，服务器转入ESTABLISHED状态.

  Syn攻击就是 攻击客户端 在短时间内伪造大量不存在的IP地址，向服务器不断地发送syn包，服务器回复确认包，并等待客户的确认，由于源地址是不存在的，服务器需要不断的重发直 至超时，这些伪造的SYN包将长时间占用未连接队列，正常的SYN请求被丢弃，目标系统运行缓慢，严重者引起网络堵塞甚至系统瘫痪。

 Syn攻击是一个典型的DDOS攻击。检测SYN攻击非常的方便，当你在服务器上看到大量的半连接状态时，特别是源IP地址是随机的，基本上可以断定这是一次SYN攻击.在Linux下可以如下命令检测是否被Syn攻击

netstat -n -p TCP | grep SYN_RECV

一般较新的TCP/IP协议栈都对这一过程进行修正来防范Syn攻击，修改tcp协议实现。主要方法有SynAttackProtect保护机制、SYN cookies技术、增加最大半连接和缩短超时时间等.

但是不能完全防范syn攻击。

TCP 四次挥手

TCP的连接的拆除需要发送四个包，因此称为四次挥手(four-way handshake)。客户端或服务器均可主动发起挥手动作，在socket编程中，任何一方执行close()操作即可产生挥手操作。

参见wireshark抓包，实测的抓包结果并没有严格按挥手时序。我估计是时间间隔太短造成。

我们的程序处于CLOSE_WAIT状态，而不是LAST_ACK状态，说明还没有发FIN给Server，那么可能是在关闭连接之前还有许多数据要发送或者其他事要做，导致没有发这个FIN packet。
原因知道了，那么为什么不发FIN包呢，难道会在关闭己方连接前有那么多事情要做吗？
还有一个问题，为什么有数千个连接都处于这个状态呢？难道那段时间内，服务器端总是主动拆除我们的连接吗？
不管怎么样，我们必须防止类似情况再度发生！
首先，我们要防止不断开辟新的端口，这可以通过设置SO_REUSEADDR套接字选项做到：
重用本地地址和端口
以前我总是一个端口不行，就换一个新的使用，所以导致让数千个端口进入CLOSE_WAIT状态。如果下次还发生这种尴尬状况，我希望加一个限定，只是当前这个端口处于CLOSE_WAIT状态！
在调用
sockConnected = socket(AF_INET, SOCK_STREAM, 0);
之后，我们要设置该套接字的选项来重用：
/// 允许重用本地地址和端口:
/// 这样的好处是，即使socket断了，调用前面的socket函数也不会占用另一个，而是始终就是一个端口
/// 这样防止socket始终连接不上，那么按照原来的做法，会不断地换端口。
int nREUSEADDR = 1;
setsockopt(sockConnected,
              SOL_SOCKET,
              SO_REUSEADDR,
              (const char*)&nREUSEADDR,
              sizeof(int));

教科书上是这么说的：这样，假如服务器关闭或者退出，造成本地地址和端口都处于TIME_WAIT状态，那么SO_REUSEADDR就显得非常有用。
也许我们无法避免被冻结在CLOSE_WAIT状态永远不出现，但起码可以保证不会占用新的端口。
其次，我们要设置SO_LINGER套接字选项：（相关介绍可参考：SO_LINGER 选项设置）
从容关闭还是强行关闭？
LINGER是“拖延”的意思。
默认情况下(Win2k)，SO_DONTLINGER套接字选项的是1；SO_LINGER选项是，linger为{l_onoff：0，l_linger：0}。
如果在发送数据的过程中(send()没有完成，还有数据没发送)而调用了closesocket()，以前我们一般采取的措施是“从容关闭”：
因为在退出服务或者每次重新建立socket之前，我都会先调用
/// 先将双向的通讯关闭
     shutdown(sockConnected, SD_BOTH);
     /// 安全起见，每次建立Socket连接前，先把这个旧连接关闭
closesocket(sockConnected);
我们这次要这么做：
设置SO_LINGER为零（亦即linger结构中的l_onoff域设为非零，但l_linger为0），便不用担心closesocket调用进入“锁定”状态（等待完成），不论是否有排队数据未发送或未被确认。这种关闭方式称为“强行关闭”，因为套接字的虚电路立即被复位，尚未发出的所有数据都会丢失。在远端的recv()调用都会失败，并返回WSAECONNRESET错误。
在connect成功建立连接之后设置该选项：
linger m_sLinger;
m_sLinger.l_onoff = 1; // (在closesocket()调用,但是还有数据没发送完毕的时候容许逗留)
m_sLinger.l_linger = 0; // (容许逗留的时间为0秒)
setsockopt(sockConnected,
         SOL_SOCKET,
         SO_LINGER,
         (const char*)&m_sLinger,
         sizeof(linger));

总结
也许我们避免不了CLOSE_WAIT状态冻结的再次出现，但我们会使影响降到最小，希望那个重用套接字选项能够使得下一次重新建立连接时可以把CLOSE_WAIT状态踢掉。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/factor2000/archive/2009/02/23/3929197.aspx

我会以一个回应反射式服务器（与《Windows网络编程》第八章一样）来介绍这五种I/O模型。
我们假设客户端的代码如下（为代码直观，省去所有错误检查，以下同）：

#include <WINSOCK2.H>
#include <stdio.h>

#define SERVER_ADDRESS "137.117.2.148"
#define PORT           5150
#define MSGSIZE        1024

#pragma comment(lib, "ws2_32.lib")

int main()
{
  WSADATA     wsaData;
  SOCKET      sClient;
  SOCKADDR_IN server;
  char        szMessage[MSGSIZE];
  int         ret;
 
  // Initialize Windows socket library
  WSAStartup(0x0202, &wsaData);

  // Create client socket
  sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Connect to server
  memset(&server, 0, sizeof(SOCKADDR_IN));
  server.sin_family = AF_INET;
  server.sin_addr.S_un.S_addr = inet_addr(SERVER_ADDRESS);
  server.sin_port = htons(PORT);

  connect(sClient, (struct sockaddr *)&server, sizeof(SOCKADDR_IN));

  while (TRUE)
  {
    printf("Send:");
  gets(szMessage);

    // Send message
    send(sClient, szMessage, strlen(szMessage), 0);

    // Receive message
    ret = recv(sClient, szMessage, MSGSIZE, 0);
    szMessage[ret] = '\0';

    printf("Received [%d bytes]: '%s'\n", ret, szMessage);
  }

  // Clean up
  closesocket(sClient);
  WSACleanup();
  return 0;
}

客户端所做的事情相当简单，创建套接字，连接服务器，然后不停的发送和接收数据。

比较容易想到的一种服务器模型就是采用一个主线程，负责监听客户端的连接请求，当接收到某个客户端的连接请求后，创建一个专门用于和该客户端通信的套接字和一个辅助线程。以后该客户端和服务器的交互都在这个辅助线程内完成。这种方法比较直观，程序非常简单而且可移植性好，但是不能利用平台相关的特性。例如，如果连接数增多的时候（成千上万的连接），那么线程数成倍增长，操作系统忙于频繁的线程间切换，而且大部分线程在其生命周期内都是处于非活动状态的，这大大浪费了系统的资源。所以，如果你已经知道你的代码只会运行在Windows平台上，建议采用Winsock I/O模型。

一.选择模型
Select（选择）模型是Winsock中最常见的I/O模型。之所以称其为“Select模型”，是由于它的“中心思想”便是利用select函数，实现对I/O的管理。最初设计该模型时，主要面向的是某些使用UNIX操作系统的计算机，它们采用的是Berkeley套接字方案。Select模型已集成到Winsock 1.1中，它使那些想避免在套接字调用过程中被无辜“锁定”的应用程序，采取一种有序的方式，同时进行对多个套接字的管理。由于Winsock 1.1向后兼容于Berkeley套接字实施方案，所以假如有一个Berkeley套接字应用使用了select函数，那么从理论角度讲，毋需对其进行任何修改，便可正常运行。（节选自《Windows网络编程》第八章)
下面的这段程序就是利用选择模型实现的Echo服务器的代码（已经不能再精简了）：

#include <winsock.h>
#include <stdio.h>

#define PORT       5150
#define MSGSIZE    1024

#pragma comment(lib, "ws2_32.lib")

int    g_iTotalConn = 0;
SOCKET g_CliSocketArr[FD_SETSIZE];

DWORD WINAPI WorkerThread(LPVOID lpParameter);

int main()
{
  WSADATA     wsaData;
  SOCKET      sListen, sClient;
  SOCKADDR_IN local, client;
  int         iaddrSize = sizeof(SOCKADDR_IN);
  DWORD       dwThreadId;

  // Initialize Windows socket library
  WSAStartup(0x0202, &wsaData);

  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
 local.sin_family = AF_INET;
 local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  // Create worker thread
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId); 

  while (TRUE)
  {
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

    // Add socket to g_CliSocketArr
    g_CliSocketArr[g_iTotalConn++] = sClient;
  }
 
  return 0;
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
  int            i;
  fd_set         fdread;
  int            ret;
  struct timeval tv = {1, 0};
  char           szMessage[MSGSIZE];
 
  while (TRUE)
  {
    FD_ZERO(&fdread);
    for (i = 0; i < g_iTotalConn; i++)
    {
      FD_SET(g_CliSocketArr[i], &fdread);
    }

    // We only care read event
    ret = select(0, &fdread, NULL, NULL, &tv);

    if (ret == 0)
    {
      // Time expired
      continue;
    }

    for (i = 0; i < g_iTotalConn; i++)
    {
      if (FD_ISSET(g_CliSocketArr[i], &fdread))
      {
        // A read event happened on g_CliSocketArr[i]
        ret = recv(g_CliSocketArr[i], szMessage, MSGSIZE, 0);
    if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
    {
     // Client socket closed
          printf("Client socket %d closed.\n", g_CliSocketArr[i]);
     closesocket(g_CliSocketArr[i]);
     if (i < g_iTotalConn - 1)
          {           
            g_CliSocketArr[i--] = g_CliSocketArr[--g_iTotalConn];
          }
        }
    else
    {
     // We received a message from client
          szMessage[ret] = '\0';
     send(g_CliSocketArr[i], szMessage, strlen(szMessage), 0);
        }
      }
    }
  }
 
  return 0;
}

服务器的几个主要动作如下：
1.创建监听套接字，绑定，监听；
2.创建工作者线程；
3.创建一个套接字数组，用来存放当前所有活动的客户端套接字，每accept一个连接就更新一次数组；
4.接受客户端的连接。这里有一点需要注意的，就是我没有重新定义FD_SETSIZE宏，所以服务器最多支持的并发连接数为64。而且，这里决不能无条件的accept,服务器应该根据当前的连接数来决定是否接受来自某个客户端的连接。一种比较好的实现方案就是采用WSAAccept函数，而且让WSAAccept回调自己实现的Condition Function。如下所示：

int CALLBACK ConditionFunc(LPWSABUF lpCallerId,LPWSABUF lpCallerData, LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,GROUP FAR * g,DWORD dwCallbackData)
{
 if (当前连接数 < FD_SETSIZE)
  return CF_ACCEPT;
 else
  return CF_REJECT;
}

工作者线程里面是一个死循环，一次循环完成的动作是：
1.将当前所有的客户端套接字加入到读集fdread中；
2.调用select函数；
3.查看某个套接字是否仍然处于读集中，如果是，则接收数据。如果接收的数据长度为0，或者发生WSAECONNRESET错误，则表示客户端套接字主动关闭，这时需要将服务器中对应的套接字所绑定的资源释放掉，然后调整我们的套接字数组（将数组中最后一个套接字挪到当前的位置上）

除了需要有条件接受客户端的连接外，还需要在连接数为0的情形下做特殊处理，因为如果读集中没有任何套接字，select函数会立刻返回，这将导致工作者线程成为一个毫无停顿的死循环，CPU的占用率马上达到100%。

二.异步选择
Winsock提供了一个有用的异步I/O模型。利用这个模型，应用程序可在一个套接字上，接收以Windows消息为基础的网络事件通知。具体的做法是在建好一个套接字后，调用WSAAsyncSelect函数。该模型最早出现于Winsock的1.1版本中，用于帮助应用程序开发者面向一些早期的16位Windows平台（如Windows for Workgroups），适应其“落后”的多任务消息环境。应用程序仍可从这种模型中得到好处，特别是它们用一个标准的Windows例程（常称为"WndProc"），对窗口消息进行管理的时候。该模型亦得到了Microsoft Foundation Class（微软基本类，MFC）对象CSocket的采纳。（节选自《Windows网络编程》第八章)
我还是先贴出代码，然后做详细解释：
#include <winsock.h>
#include <tchar.h>

#define PORT      5150
#define MSGSIZE   1024
#define WM_SOCKET WM_USER+0

#pragma comment(lib, "ws2_32.lib")

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
  static TCHAR szAppName[] = _T("AsyncSelect Model");
  HWND         hwnd ;
  MSG          msg ;
  WNDCLASS     wndclass ;

  wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
  wndclass.lpfnWndProc   = WndProc ;
  wndclass.cbClsExtra    = 0 ;
  wndclass.cbWndExtra    = 0 ;
  wndclass.hInstance     = hInstance ;
  wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
  wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
  wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
  wndclass.lpszMenuName  = NULL ;
  wndclass.lpszClassName = szAppName ;

  if (!RegisterClass(&wndclass))
  {
    MessageBox (NULL, TEXT ("This program requires Windows NT!"), szAppName, MB_ICONERROR) ;
    return 0 ;
  }

  hwnd = CreateWindow (szAppName,                  // window class name
                       TEXT ("AsyncSelect Model"), // window caption
                       WS_OVERLAPPEDWINDOW,        // window style
                       CW_USEDEFAULT,              // initial x position
                       CW_USEDEFAULT,              // initial y position
                       CW_USEDEFAULT,              // initial x size
                       CW_USEDEFAULT,              // initial y size
                       NULL,                       // parent window handle
                       NULL,                       // window menu handle
                       hInstance,                  // program instance handle
                       NULL) ;                     // creation parameters

  ShowWindow(hwnd, iCmdShow);
  UpdateWindow(hwnd);

  while (GetMessage(&msg, NULL, 0, 0))
  {
    TranslateMessage(&msg) ;
    DispatchMessage(&msg) ;
  }
 
  return msg.wParam;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  WSADATA       wsd;
  static SOCKET sListen;
  SOCKET        sClient;
  SOCKADDR_IN   local, client;
  int           ret, iAddrSize = sizeof(client);
  char          szMessage[MSGSIZE];

  switch (message)
  {
 case WM_CREATE:
    // Initialize Windows Socket library
  WSAStartup(0x0202, &wsd);
 
  // Create listening socket
    sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   
  // Bind
    local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
  local.sin_family = AF_INET;
  local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(local));
 
  // Listen
    listen(sListen, 3);

    // Associate listening socket with FD_ACCEPT event
  WSAAsyncSelect(sListen, hwnd, WM_SOCKET, FD_ACCEPT);
  return 0;

  case WM_DESTROY:
    closesocket(sListen);
    WSACleanup();
    PostQuitMessage(0);
    return 0;
 
  case WM_SOCKET:
    if (WSAGETSELECTERROR(lParam))
    {
      closesocket(wParam);
      break;
    }
   
    switch (WSAGETSELECTEVENT(lParam))
    {
    case FD_ACCEPT:
      // Accept a connection from client
      sClient = accept(wParam, (struct sockaddr *)&client, &iAddrSize);
     
      // Associate client socket with FD_READ and FD_CLOSE event
      WSAAsyncSelect(sClient, hwnd, WM_SOCKET, FD_READ | FD_CLOSE);
      break;

    case FD_READ:
      ret = recv(wParam, szMessage, MSGSIZE, 0);

      if (ret == 0 || ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET)
      {
        closesocket(wParam);
      }
      else
      {
        szMessage[ret] = '\0';
        send(wParam, szMessage, strlen(szMessage), 0);
      }
      break;
     
    case FD_CLOSE:
      closesocket(wParam);     
      break;
    }
    return 0;
  }
 
  return DefWindowProc(hwnd, message, wParam, lParam);
}

 在我看来，WSAAsyncSelect是最简单的一种Winsock I/O模型（之所以说它简单是因为一个主线程就搞定了）。使用Raw Windows API写过窗口类应用程序的人应该都能看得懂。这里，我们需要做的仅仅是：
1.在WM_CREATE消息处理函数中，初始化Windows Socket library，创建监听套接字，绑定，监听，并且调用WSAAsyncSelect函数表示我们关心在监听套接字上发生的FD_ACCEPT事件；
2.自定义一个消息WM_SOCKET，一旦在我们所关心的套接字（监听套接字和客户端套接字）上发生了某个事件，系统就会调用WndProc并且message参数被设置为WM_SOCKET；
3.在WM_SOCKET的消息处理函数中，分别对FD_ACCEPT、FD_READ和FD_CLOSE事件进行处理；
4.在窗口销毁消息(WM_DESTROY)的处理函数中，我们关闭监听套接字，清除Windows Socket library

下面这张用于WSAAsyncSelect函数的网络事件类型表可以让你对各个网络事件有更清楚的认识：
表1

FD_READ 应用程序想要接收有关是否可读的通知，以便读入数据
FD_WRITE 应用程序想要接收有关是否可写的通知，以便写入数据
FD_OOB 应用程序想接收是否有带外（OOB）数据抵达的通知
FD_ACCEPT 应用程序想接收与进入连接有关的通知
FD_CONNECT 应用程序想接收与一次连接或者多点join操作完成的通知
FD_CLOSE 应用程序想接收与套接字关闭有关的通知
FD_QOS 应用程序想接收套接字“服务质量”（QoS）发生更改的通知
FD_GROUP_QOS  应用程序想接收套接字组“服务质量”发生更改的通知（现在没什么用处，为未来套接字组的使用保留）
FD_ROUTING_INTERFACE_CHANGE 应用程序想接收在指定的方向上，与路由接口发生变化的通知
FD_ADDRESS_LIST_CHANGE  应用程序想接收针对套接字的协议家族，本地地址列表发生变化的通知

三.事件选择
Winsock提供了另一个有用的异步I/O模型。和WSAAsyncSelect模型类似的是，它也允许应用程序在一个或多个套接字上，接收以事件为基础的网络事件通知。对于表1总结的、由WSAAsyncSelect模型采用的网络事件来说，它们均可原封不动地移植到新模型。在用新模型开发的应用程序中，也能接收和处理所有那些事件。该模型最主要的差别在于网络事件会投递至一个事件对象句柄，而非投递至一个窗口例程。（节选自《Windows网络编程》第八章)
还是让我们先看代码然后进行分析：
#include <winsock2.h>
#include <stdio.h>

#define PORT    5150
#define MSGSIZE 1024

#pragma comment(lib, "ws2_32.lib")

int      g_iTotalConn = 0;
SOCKET   g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
WSAEVENT g_CliEventArr[MAXIMUM_WAIT_OBJECTS];

DWORD WINAPI WorkerThread(LPVOID);
void Cleanup(int index);

int main()
{
  WSADATA     wsaData;
  SOCKET      sListen, sClient;
  SOCKADDR_IN local, client;
  DWORD       dwThreadId;
  int         iaddrSize = sizeof(SOCKADDR_IN);

  // Initialize Windows Socket library
  WSAStartup(0x0202, &wsaData);

  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
 local.sin_family = AF_INET;
 local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  // Create worker thread
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

  while (TRUE)
  {
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

    // Associate socket with network event
    g_CliSocketArr[g_iTotalConn] = sClient;
    g_CliEventArr[g_iTotalConn] = WSACreateEvent();
    WSAEventSelect(g_CliSocketArr[g_iTotalConn],
                   g_CliEventArr[g_iTotalConn],
                   FD_READ | FD_CLOSE);
    g_iTotalConn++;
  }
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
  int              ret, index;
  WSANETWORKEVENTS NetworkEvents;
  char             szMessage[MSGSIZE];

  while (TRUE)
  {
    ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);
    if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
    {
      continue;
    }

    index = ret - WSA_WAIT_EVENT_0;
    WSAEnumNetworkEvents(g_CliSocketArr[index], g_CliEventArr[index], &NetworkEvents);

    if (NetworkEvents.lNetworkEvents & FD_READ)
    {
      // Receive message from client
      ret = recv(g_CliSocketArr[index], szMessage, MSGSIZE, 0);
      if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
      {
        Cleanup(index);
      }
      else
      {
        szMessage[ret] = '\0';
        send(g_CliSocketArr[index], szMessage, strlen(szMessage), 0);
      }
    }

    if (NetworkEvents.lNetworkEvents & FD_CLOSE)
  {
   Cleanup(index);
  }
  }
  return 0;
}

void Cleanup(int index)
{
  closesocket(g_CliSocketArr[index]);
 WSACloseEvent(g_CliEventArr[index]);

 if (index < g_iTotalConn - 1)
 {
  g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn - 1];
  g_CliEventArr[index] = g_CliEventArr[g_iTotalConn - 1];
 }
 
 g_iTotalConn--;
}

事件选择模型也比较简单，实现起来也不是太复杂，它的基本思想是将每个套接字都和一个WSAEVENT对象对应起来，并且在关联的时候指定需要关注的哪些网络事件。一旦在某个套接字上发生了我们关注的事件（FD_READ和FD_CLOSE），与之相关联的WSAEVENT对象被Signaled。程序定义了两个全局数组，一个套接字数组，一个WSAEVENT对象数组，其大小都是MAXIMUM_WAIT_OBJECTS（64），两个数组中的元素一一对应。
同样的，这里的程序没有考虑两个问题，一是不能无条件的调用accept，因为我们支持的并发连接数有限。解决方法是将套接字按MAXIMUM_WAIT_OBJECTS分组，每MAXIMUM_WAIT_OBJECTS个套接字一组，每一组分配一个工作者线程；或者采用WSAAccept代替accept，并回调自己定义的Condition Function。第二个问题是没有对连接数为0的情形做特殊处理，程序在连接数为0的时候CPU占用率为100%。

四.重叠I/O模型
Winsock2的发布使得Socket I/O有了和文件I/O统一的接口。我们可以通过使用Win32文件操纵函数ReadFile和WriteFile来进行Socket I/O。伴随而来的，用于普通文件I/O的重叠I/O模型和完成端口模型对Socket I/O也适用了。这些模型的优点是可以达到更佳的系统性能，但是实现较为复杂，里面涉及较多的C语言技巧。例如我们在完成端口模型中会经常用到所谓的“尾随数据”。

1.用事件通知方式实现的重叠I/O模型
#include <winsock2.h>
#include <stdio.h>

#define PORT    5150
#define MSGSIZE 1024

#pragma comment(lib, "ws2_32.lib")

typedef struct
{
  WSAOVERLAPPED overlap;
  WSABUF        Buffer;
  char          szMessage[MSGSIZE];
  DWORD         NumberOfBytesRecvd;
  DWORD         Flags;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

int                     g_iTotalConn = 0;
SOCKET                  g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
WSAEVENT                g_CliEventArr[MAXIMUM_WAIT_OBJECTS];
LPPER_IO_OPERATION_DATA g_pPerIODataArr[MAXIMUM_WAIT_OBJECTS];

DWORD WINAPI WorkerThread(LPVOID);
void Cleanup(int);

int main()
{
  WSADATA     wsaData;
  SOCKET      sListen, sClient;
  SOCKADDR_IN local, client;
  DWORD       dwThreadId;
  int         iaddrSize = sizeof(SOCKADDR_IN);

  // Initialize Windows Socket library
  WSAStartup(0x0202, &wsaData);

  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
 local.sin_family = AF_INET;
 local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  // Create worker thread
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

  while (TRUE)
  {
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

    g_CliSocketArr[g_iTotalConn] = sClient;
   
    // Allocate a PER_IO_OPERATION_DATA structure
    g_pPerIODataArr[g_iTotalConn] = (LPPER_IO_OPERATION_DATA)HeapAlloc(
      GetProcessHeap(),
      HEAP_ZERO_MEMORY,
      sizeof(PER_IO_OPERATION_DATA));
    g_pPerIODataArr[g_iTotalConn]->Buffer.len = MSGSIZE;
    g_pPerIODataArr[g_iTotalConn]->Buffer.buf = g_pPerIODataArr[g_iTotalConn]->szMessage;
    g_CliEventArr[g_iTotalConn] = g_pPerIODataArr[g_iTotalConn]->overlap.hEvent = WSACreateEvent();

    // Launch an asynchronous operation
    WSARecv(
      g_CliSocketArr[g_iTotalConn],
      &g_pPerIODataArr[g_iTotalConn]->Buffer,
      1,
      &g_pPerIODataArr[g_iTotalConn]->NumberOfBytesRecvd,
      &g_pPerIODataArr[g_iTotalConn]->Flags,
      &g_pPerIODataArr[g_iTotalConn]->overlap,
      NULL);
   
    g_iTotalConn++;
  }
 
  closesocket(sListen);
  WSACleanup();
  return 0;
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
  int   ret, index;
  DWORD cbTransferred;

  while (TRUE)
  {
    ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);
    if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
    {
      continue;
    }

    index = ret - WSA_WAIT_EVENT_0;
    WSAResetEvent(g_CliEventArr[index]);

    WSAGetOverlappedResult(
      g_CliSocketArr[index],
      &g_pPerIODataArr[index]->overlap,
      &cbTransferred,
      TRUE,
      &g_pPerIODataArr[g_iTotalConn]->Flags);

    if (cbTransferred == 0)
    {
      // The connection was closed by client
      Cleanup(index);
    }
    else
    {
      // g_pPerIODataArr[index]->szMessage contains the received data
      g_pPerIODataArr[index]->szMessage[cbTransferred] = '\0';
      send(g_CliSocketArr[index], g_pPerIODataArr[index]->szMessage,\
        cbTransferred, 0);

      // Launch another asynchronous operation
      WSARecv(
        g_CliSocketArr[index],
        &g_pPerIODataArr[index]->Buffer,
        1,
        &g_pPerIODataArr[index]->NumberOfBytesRecvd,
        &g_pPerIODataArr[index]->Flags,
        &g_pPerIODataArr[index]->overlap,
        NULL);
    }
  }

  return 0;
}

void Cleanup(int index)
{
  closesocket(g_CliSocketArr[index]);
  WSACloseEvent(g_CliEventArr[index]);
  HeapFree(GetProcessHeap(), 0, g_pPerIODataArr[index]);

  if (index < g_iTotalConn - 1)
  {
    g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn - 1];
    g_CliEventArr[index] = g_CliEventArr[g_iTotalConn - 1];
    g_pPerIODataArr[index] = g_pPerIODataArr[g_iTotalConn - 1];
  }

  g_pPerIODataArr[--g_iTotalConn] = NULL;
}

 这个模型与上述其他模型不同的是它使用Winsock2提供的异步I/O函数WSARecv。在调用WSARecv时，指定一个WSAOVERLAPPED结构，这个调用不是阻塞的，也就是说，它会立刻返回。一旦有数据到达的时候，被指定的WSAOVERLAPPED结构中的hEvent被Signaled。由于下面这个语句
g_CliEventArr[g_iTotalConn] = g_pPerIODataArr[g_iTotalConn]->overlap.hEvent；
使得与该套接字相关联的WSAEVENT对象也被Signaled，所以WSAWaitForMultipleEvents的调用操作成功返回。我们现在应该做的就是用与调用WSARecv相同的WSAOVERLAPPED结构为参数调用WSAGetOverlappedResult，从而得到本次I/O传送的字节数等相关信息。在取得接收的数据后，把数据原封不动的发送到客户端，然后重新激活一个WSARecv异步操作。

2.用完成例程方式实现的重叠I/O模型
#include <WINSOCK2.H>
#include <stdio.h>

#define PORT    5150
#define MSGSIZE 1024

#pragma comment(lib, "ws2_32.lib")

typedef struct
{
 WSAOVERLAPPED overlap;
 WSABUF        Buffer;
  char          szMessage[MSGSIZE];
 DWORD         NumberOfBytesRecvd;
 DWORD         Flags;
 SOCKET        sClient;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

DWORD WINAPI WorkerThread(LPVOID);
void CALLBACK CompletionROUTINE(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);

SOCKET g_sNewClientConnection;
BOOL   g_bNewConnectionArrived = FALSE;

int main()
{
  WSADATA     wsaData;
  SOCKET      sListen;
  SOCKADDR_IN local, client;
  DWORD       dwThreadId;
  int         iaddrSize = sizeof(SOCKADDR_IN);

  // Initialize Windows Socket library
  WSAStartup(0x0202, &wsaData);

  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
 local.sin_family = AF_INET;
 local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  // Create worker thread
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

  while (TRUE)
  {
    // Accept a connection
    g_sNewClientConnection = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    g_bNewConnectionArrived = TRUE;
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
  }
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
 LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

  while (TRUE)
  {
    if (g_bNewConnectionArrived)
    {
      // Launch an asynchronous operation for new arrived connection
      lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
        GetProcessHeap(),
        HEAP_ZERO_MEMORY,
        sizeof(PER_IO_OPERATION_DATA));
      lpPerIOData->Buffer.len = MSGSIZE;
      lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
      lpPerIOData->sClient = g_sNewClientConnection;
     
      WSARecv(lpPerIOData->sClient,
        &lpPerIOData->Buffer,
        1,
        &lpPerIOData->NumberOfBytesRecvd,
        &lpPerIOData->Flags,
        &lpPerIOData->overlap,
        CompletionROUTINE);     
     
      g_bNewConnectionArrived = FALSE;
    }

    SleepEx(1000, TRUE);
  }
  return 0;
}

void CALLBACK CompletionROUTINE(DWORD dwError,
                                DWORD cbTransferred,
                                LPWSAOVERLAPPED lpOverlapped,
                                DWORD dwFlags)
{
  LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped;
 
  if (dwError != 0 || cbTransferred == 0)
 {
    // Connection was closed by client
  closesocket(lpPerIOData->sClient);
  HeapFree(GetProcessHeap(), 0, lpPerIOData);
 }
  else
  {
    lpPerIOData->szMessage[cbTransferred] = '\0';
    send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);
   
    // Launch another asynchronous operation
    memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));
    lpPerIOData->Buffer.len = MSGSIZE;
    lpPerIOData->Buffer.buf = lpPerIOData->szMessage;   

    WSARecv(lpPerIOData->sClient,
      &lpPerIOData->Buffer,
      1,
      &lpPerIOData->NumberOfBytesRecvd,
      &lpPerIOData->Flags,
      &lpPerIOData->overlap,
      CompletionROUTINE);
  }
}

用完成例程来实现重叠I/O比用事件通知简单得多。在这个模型中，主线程只用不停的接受连接即可；辅助线程判断有没有新的客户端连接被建立，如果有，就为那个客户端套接字激活一个异步的WSARecv操作，然后调用SleepEx使线程处于一种可警告的等待状态，以使得I/O完成后CompletionROUTINE可以被内核调用。如果辅助线程不调用SleepEx，则内核在完成一次I/O操作后，无法调用完成例程（因为完成例程的运行应该和当初激活WSARecv异步操作的代码在同一个线程之内）。
完成例程内的实现代码比较简单，它取出接收到的数据，然后将数据原封不动的发送给客户端，最后重新激活另一个WSARecv异步操作。注意，在这里用到了“尾随数据”。我们在调用WSARecv的时候，参数lpOverlapped实际上指向一个比它大得多的结构PER_IO_OPERATION_DATA，这个结构除了WSAOVERLAPPED以外，还被我们附加了缓冲区的结构信息，另外还包括客户端套接字等重要的信息。这样，在完成例程中通过参数lpOverlapped拿到的不仅仅是WSAOVERLAPPED结构，还有后边尾随的包含客户端套接字和接收数据缓冲区等重要信息。这样的C语言技巧在我后面介绍完成端口的时候还会使用到。

五.完成端口模型
“完成端口”模型是迄今为止最为复杂的一种I/O模型。然而，假若一个应用程序同时需要管理为数众多的套接字，那么采用这种模型，往往可以达到最佳的系统性能！但不幸的是，该模型只适用于Windows NT和Windows 2000操作系统。因其设计的复杂性，只有在你的应用程序需要同时管理数百乃至上千个套接字的时候，而且希望随着系统内安装的CPU数量的增多，应用程序的性能也可以线性提升，才应考虑采用“完成端口”模型。要记住的一个基本准则是，假如要为Windows NT或Windows 2000开发高性能的服务器应用，同时希望为大量套接字I/O请求提供服务（Web服务器便是这方面的典型例子），那么I/O完成端口模型便是最佳选择！（节选自《Windows网络编程》第八章）
完成端口模型是我最喜爱的一种模型。虽然其实现比较复杂（其实我觉得它的实现比用事件通知实现的重叠I/O简单多了），但其效率是惊人的。我在T公司的时候曾经帮同事写过一个邮件服务器的性能测试程序，用的就是完成端口模型。结果表明，完成端口模型在多连接（成千上万）的情况下，仅仅依靠一两个辅助线程，就可以达到非常高的吞吐量。下面我还是从代码说起：
#include <WINSOCK2.H>
#include <stdio.h>

#define PORT    5150
#define MSGSIZE 1024

#pragma comment(lib, "ws2_32.lib")

typedef enum
{
  RECV_POSTED
}OPERATION_TYPE;

typedef struct
{
 WSAOVERLAPPED  overlap;
 WSABUF         Buffer;
  char           szMessage[MSGSIZE];
 DWORD          NumberOfBytesRecvd;
 DWORD          Flags;
 OPERATION_TYPE OperationType;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

DWORD WINAPI WorkerThread(LPVOID);

int main()
{
  WSADATA                 wsaData;
  SOCKET                  sListen, sClient;
  SOCKADDR_IN             local, client;
  DWORD                   i, dwThreadId;
  int                     iaddrSize = sizeof(SOCKADDR_IN);
  HANDLE                  CompletionPort = INVALID_HANDLE_VALUE;
  SYSTEM_INFO             systeminfo;
  LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

  // Initialize Windows Socket library
  WSAStartup(0x0202, &wsaData);

  // Create completion port
  CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);

  // Create worker thread
  GetSystemInfo(&systeminfo);
  for (i = 0; i < systeminfo.dwNumberOfProcessors; i++)
  {
    CreateThread(NULL, 0, WorkerThread, CompletionPort, 0, &dwThreadId);
  }
 
  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
 local.sin_family = AF_INET;
 local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  while (TRUE)
  {
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

    // Associate the newly arrived client socket with completion port
    CreateIoCompletionPort((HANDLE)sClient, CompletionPort, (DWORD)sClient, 0);
   
    // Launch an asynchronous operation for new arrived connection
    lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
      GetProcessHeap(),
      HEAP_ZERO_MEMORY,
      sizeof(PER_IO_OPERATION_DATA));
    lpPerIOData->Buffer.len = MSGSIZE;
    lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
    lpPerIOData->OperationType = RECV_POSTED;
    WSARecv(sClient,
      &lpPerIOData->Buffer,
      1,
      &lpPerIOData->NumberOfBytesRecvd,
      &lpPerIOData->Flags,
      &lpPerIOData->overlap,
      NULL);
  }

  PostQueuedCompletionStatus(CompletionPort, 0xFFFFFFFF, 0, NULL);
 CloseHandle(CompletionPort);
 closesocket(sListen);
 WSACleanup();
 return 0;
}

DWORD WINAPI WorkerThread(LPVOID CompletionPortID)
{
  HANDLE                  CompletionPort=(HANDLE)CompletionPortID;
  DWORD                   dwBytesTransferred;
  SOCKET                  sClient;
  LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

  while (TRUE)
  {
    GetQueuedCompletionStatus(
      CompletionPort,
      &dwBytesTransferred,
      &sClient,
      (LPOVERLAPPED *)&lpPerIOData,
      INFINITE);
    if (dwBytesTransferred == 0xFFFFFFFF)
    {
      return 0;
    }
   
    if (lpPerIOData->OperationType == RECV_POSTED)
    {
      if (dwBytesTransferred == 0)
      {
        // Connection was closed by client
        closesocket(sClient);
        HeapFree(GetProcessHeap(), 0, lpPerIOData);       
      }
      else
      {
        lpPerIOData->szMessage[dwBytesTransferred] = '\0';
        send(sClient, lpPerIOData->szMessage, dwBytesTransferred, 0);
       
        // Launch another asynchronous operation for sClient
        memset(lpPerIOData, 0, sizeof(PER_IO_OPERATION_DATA));
        lpPerIOData->Buffer.len = MSGSIZE;
        lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
        lpPerIOData->OperationType = RECV_POSTED;
        WSARecv(sClient,
          &lpPerIOData->Buffer,
          1,
          &lpPerIOData->NumberOfBytesRecvd,
          &lpPerIOData->Flags,
          &lpPerIOData->overlap,
          NULL);
      }
    }
  }
 return 0;
}

 首先，说说主线程：
1.创建完成端口对象
2.创建工作者线程（这里工作者线程的数量是按照CPU的个数来决定的，这样可以达到最佳性能）
3.创建监听套接字，绑定，监听，然后程序进入循环
4.在循环中，我做了以下几件事情：
 (1).接受一个客户端连接
 (2).将该客户端套接字与完成端口绑定到一起(还是调用CreateIoCompletionPort，但这次的作用不同)，注意，按道理来讲，此时传递给CreateIoCompletionPort的第三个参数应该是一个完成键，一般来讲，程序都是传递一个单句柄数据结构的地址，该单句柄数据包含了和该客户端连接有关的信息，由于我们只关心套接字句柄，所以直接将套接字句柄作为完成键传递；
 (3).触发一个WSARecv异步调用，这次又用到了“尾随数据”，使接收数据所用的缓冲区紧跟在WSAOVERLAPPED对象之后，此外，还有操作类型等重要信息。
 
在工作者线程的循环中，我们
1.调用GetQueuedCompletionStatus取得本次I/O的相关信息（例如套接字句柄、传送的字节数、单I/O数据结构的地址等等）
2.通过单I/O数据结构找到接收数据缓冲区，然后将数据原封不动的发送到客户端
3.再次触发一个WSARecv异步操作

六.五种I/O模型的比较
我会从以下几个方面来进行比较
*有无每线程64连接数限制
如果在选择模型中没有重新定义FD_SETSIZE宏，则每个fd_set默认可以装下64个SOCKET。同样的，受MAXIMUM_WAIT_OBJECTS宏的影响，事件选择、用事件通知实现的重叠I/O都有每线程最大64连接数限制。如果连接数成千上万，则必须对客户端套接字进行分组，这样，势必增加程序的复杂度。
相反，异步选择、用完成例程实现的重叠I/O和完成端口不受此限制。

*线程数
除了异步选择以外，其他模型至少需要2个线程。一个主线程和一个辅助线程。同样的，如果连接数大于64，则选择模型、事件选择和用事件通知实现的重叠I/O的线程数还要增加。

*实现的复杂度
我的个人看法是，在实现难度上，异步选择<选择<用完成例程实现的重叠I/O<事件选择<完成端口<用事件通知实现的重叠I/O

*性能
由于选择模型中每次都要重设读集，在select函数返回后还要针对所有套接字进行逐一测试，我的感觉是效率比较差；完成端口和用完成例程实现的重叠I/O基本上不涉及全局数据，效率应该是最高的，而且在多处理器情形下完成端口还要高一些；事件选择和用事件通知实现的重叠I/O在实现机制上都是采用WSAWaitForMultipleEvents，感觉效率差不多；至于异步选择，不好比较。所以我的结论是:选择<用事件通知实现的重叠I/O<事件选择<用完成例程实现的重叠I/O<完成端口

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/mlite/archive/2006/04/30/699340.aspx

  关于完成端口网上有很多文章，不过我个人觉得大多都讲得不够清楚。给的例子要不就是给一个复杂的封装，要不就是给一个简单的收发数据。注意，完成端口不仅仅用于网络数据的收发，它可以用于windows 平台的各种IO操作。不过我这里只关注在winsock编程中的应用。

    要写出一篇真的让人能够明白的文章，不那么容易。这里我只暂时贴些我的理解。迟些时候如果有空的话，我倒有兴趣写个详细的入门文章。

1.26.2008

Kevin Lynx

 
理解完成端口：
 
       就目前所了解的信息来说，完成端口通常都会与重叠IO有关联。完成端口可被看作是一个队列。各种操作都会被放到该队列里，程序在迟些时候查询此队列获取之前提交的IO操作结果。

       注意，无论是重叠IO还是完成端口，都不仅仅用于socket的操作，他们是用于各种IO的操作。

IOCP不是为每一个客户端连接建立一个线程。

要区分IOCP和事件通知模型的区别，事件通知模型是先得到事件，然后根据事件类型去获取或者发送数据；而IOCP则是先提交动作（发送或接收），后得到通知，当得到通知时，通常就意味着之前提交的动作已经完成了。

 
When you use IOCP, you spawn a pool of threads once - and they are used to handle the network I/O in your application. Technically, in Windows 2000, you don't even have to spawn the pool yourself - you can let Windows take care of the spawning and management of the threads in the pool。

IOCP其实也属于一种同步对象，就像Windows里的Event对象一样。IOCP用于同步IO操作。在异步IO操作中，提交了一个异步操作后，某些时候就需要得知操作的结果，也就是同步一下。

 
http://www.codeproject.com/KB/IP/iocp_server_client.aspx
A server application is fairly meaningless if it cannot service multiple clients at the same time, usually asynchronous I/O calls and multithreading is used for this purpose. By definition, an asynchronous I/O call returns immediately, leaving the I/O call pending. At some point of time, the result of the I/O asynchronous call must be synchronized with the main thread. This can be done in different ways. The synchronization can be performed by:
•Using events - A signal is set as soon as the asynchronous call is finished. The disadvantage of this approach is that the thread has to check or wait for the event to be set. •Using the GetOverlappedResult function - This approach has the same disadvantage as the approach above. •Using Asynchronous Procedure Calls (or APC) - There are several disadvantages associated with this approach. First, the APC is always called in the context of the calling thread, and second, in order to be able to execute the APCs, the calling thread has to be suspended in the so called alterable wait state. •Using IOCP - The disadvantage of this approach is that there are many practical thorny programming problems that must be solved. Coding IOCP can be a bit of a hassle. 
这里我要特别强调一下异步IO和非阻塞IO的区别，异步IO就是把IO提交给系统，让系统替你做，做完了再用某种方式通知你；非阻塞IO就是你要通过某种方式不定时地向系统询问你是否可以开始做某个IO，当可以开始后，还是要自己来完成IO。
 
       不可以通过接受数据是否为0来判断客户端是否断开，只有当调用closesocket时才可以通过这个方法判断，如果是意外退出（断电，网络故障），则判断不出。这个时候可以采用定时发送数据（心跳信息）来确认。

 
       创建IOCP程序，一般的步骤：

1.       创建一个单句柄数据结构体，该结构体里一般都包含一个套接字数据。因为IOCP实际上会有固定的几个线程（工作线程），这些线程在IOCP结果队列里查询IO操作结果。这些结果不止是在一个套接字上进行的操作（读或写），而是包括了所有与该IOCP对象关联起来的套接字上的操作结果。因此，为了区分某次操作结果属于哪个套接字，就需要这个单句柄数据结构里包含这个套接字句柄。

2.       创建一个以OVERLAPPED为首个元素的数据结构体。该结构体实际上对应着一个IO操作（例如WSASend）。对于 WSASend, WSARecv以及查询操作结果函数都需要一个OVERLAPPED参数（一般是指针），通常情况下我们需要更多的数据，因此定义的这个结构体里通常包含了更多的数据（例如WSABUF，它可以用来容纳WSARecv接受到的数据）。之所以要把OVERLAPPED 作为这个结构体的第一个元素，是为了在使用查询函数GetQueuedCompletionStatus后，可以通过该函数返回的OVERLAPPED类型的指针得到我们这里定义的结构体对象地址，从而获取更多的数据。

3.       每一次接受到新的连接时(accept)，都将这个新的套接字与完成端口相关联。并且创建一个单句柄对象（也就是完成键）。每一个套接字都有一个关联的单句柄对象。而每一个IO操作都有一个关联的OVERLAPPED相关的数据结构（上一步定义的结构体）。

4.       可以在任何时候提交异步IO请求，例如WSASend, WSARecv。这里需要为OVERLAPPED相关的结构体指定操作类型。一个典型的结构体为（即第二步定义的结构体）：

              struct IOContext
{
              /// 很多函数需要此参数
              OVERLAPPED ol;
              /// 存放接受数据
              char buf[MAX_BUF];
              ///
              WSABUF wsabuf;
              /// 操作类型，提交IO操作时指定该值，在查询操作结果时，可以重新获取到该值
              int op_type;
};
在创建该结构体的变量时，为op_type指定一个值。然后将此结构体的地址给WSASend之类的函数。在工作者线程中执行查询时，实际上得到了该结构体的地址（结构体变量），那么，就可以获取op_type的值。
注意：查询结构只能获取IO操作的字节数(以及IO操作结果数据)，不能知道IO操作的类型。所以IO操作的类型实际上是在这里用户自己指定的。
当执行WSASend时，设置op_type为SEND（自己定义的常量），执行WSARecv时，指定READ。然后在查询结果时，可以根据op_type知道这个操作结果是什么类型。如果是SEND，那么就表示之前提交的WSASend操作。
IOCP是一个异步操作机制，之所以是异步，就是因为可以随时提交IO操作。提交之后具体的操作由系统为你完成。完成后就需要某种机制来得知操作结果。IOCP设置的这个结果队列就是一种机制。
 
      
 
5.       可以通过PostQueuedCompletionStatus手动地往结果队列里放置一个操作结果。通常这个函数都用于让工作者线程退出。例如：

                   PostQueuedCompletionStatus( cp_handle, 0, NULL, NULL );
然后在工作者线程里：

         ret = GetQueuedCompletionStatus( cp_handle, &transfer_bytes, (PULONG_PTR) &hc,
              (LPOVERLAPPED*)&ic, INFINITE );
         if( ic == NULL )
         {
              printf( "ic == NULL\n" );
              /*
                   使用PostQueuedCompletionStatus传递过来的数据，
                   这里约定ic==NULL时退出
              */
              break;
         }
        
6.     如果不提交任何IO操作，那么结果队列里很有可能一直都是空的。那么GetQueued这个查询函数就会一直得不到数据。
 
7.     纵观IOCP程序，一个比较复杂的地方在于资源的释放。在接收到一个新的连接时，会为这个连接创建单句柄数据，执行IO操作的话，还要创建OVERLAPPED相关结构体变量。这些变量的地址都会在工作者线程中通过GetQueued..函数获取，并在工作者线程中使用。一个比较直接的做法是在工作者线程中释放这些资源。
 
 
 
推荐些文章：

几种socket模型的代码：http://blog.csdn.net/mlite/archive/2006/04/30/699340.aspx
                  又一个简单的IOCP代码：http://www.go321.cn/html/app/cpp/20070526/30207.html
                  另一个例子，那幅图有点意义：http://www.3800hk.com/Article/cxsj/vc/wllbcvc/2005-08-25/Article_54111.html
                  codeproject上的文章：http://www.codeproject.com/KB/IP/iocp_server_client.aspx
                  codeproject上的另一篇：http://www.codeproject.com/KB/IP/jbsocketserver1.aspx
                  MSDN上的，前部分由点意义：http://msdn.microsoft.com/msdnmag/issues/1000/winsock/
                
                 其实完成端口的例子在细节上有很多方法，例如accept, AcceptEx之类，对于accept的处理尤其多。这些无疑又给初学者带来了迷惑。我觉得只要把握住几个要点就行了：异步操作，结果队列，数据的传送（提交操作时传进去，查询时取出来），工作者线程