Windows 完成端口

#include  < winsock2.h >
#include  < windows.h >
#include  < stdio.h >

#pragma comment(lib,  " Ws2_32 " )

#define  BUFFER_SIZE 1024

typedef  struct  _PER_HANDLE_DATA         //  per-handle数据
{
    SOCKET s;                         //  对应的套接字句柄
    sockaddr_in addr;                 //  客户方地址

} PER_HANDLE_DATA,  * PPER_HANDLE_DATA;


typedef  struct  _PER_IO_DATA             //  per-I/O数据
{
    OVERLAPPED ol;                 //  重叠结构
     char  buf[BUFFER_SIZE];         //  数据缓冲区
     int  nOperationType;             //  操作类型

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

} PER_IO_DATA,  * PPER_IO_DATA;


DWORD WINAPI ServerThread(LPVOID lpParam);


int  main( void )
{
    WORD wVersionRequested;
    WSADATA wsaData;
    wVersionRequested  =  MAKEWORD(  2 ,  2  );
    WSAStartup( wVersionRequested,  & wsaData );

    unsigned  short  nPort  =   8000 ;

     //  创建完成端口对象，创建工作线程处理完成端口对象中事件
    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;

     int  ret  =  ::bind(sListen, (sockaddr * ) & si,  sizeof (si));
     if  (ret  !=   0 )
    {
        perror( " bind " );
         return   - 1 ;
    }

    ret  =  ::listen(sListen,  5 );
     if  (ret  !=   0 )
    {
        perror( " listen " );
         return   - 1 ;
    }

     //  循环处理到来的连接
     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);
        
        ::CreateIoCompletionPort((HANDLE)pPerHandle -> s, hCompletion, (DWORD)pPerHandle,  0 );

         //  投递一个接收请求
        PPER_IO_DATA pPerIO  =  (PPER_IO_DATA)::GlobalAlloc(GPTR,  sizeof (PER_IO_DATA));
        pPerIO -> nOperationType  =  OP_READ;

        
        WSABUF buf;
        buf.buf  =  pPerIO -> buf;
        buf.len  =  BUFFER_SIZE;     
        
        DWORD dwRecv;
        DWORD dwFlags  =   0 ;
        
        ::WSARecv(pPerHandle -> s,  & buf,  1 ,  & dwRecv,  & dwFlags,  & pPerIO -> ol, NULL);
    }

    WSACleanup();
     return   0 ;
}


//  I/O服务线程循环调用GetQueuedCompletionStatus函数从I/O完成端口移除完成的I/O封包，然后根据封包的类型进行处理。具体程序代码如下：
DWORD WINAPI ServerThread(LPVOID lpParam)
{       
     //  得到完成端口对象句柄

    HANDLE hCompletion  =  (HANDLE)lpParam;

    DWORD dwTrans;

    PPER_HANDLE_DATA pPerHandle;

    PPER_IO_DATA pPerIO;

     while (TRUE)
    {       
        
         //  在关联到此完成端口的所有套接字上等待I/O完成

        BOOL bOK  =  ::GetQueuedCompletionStatus(hCompletion, 
             & dwTrans, (LPDWORD) & pPerHandle, (LPOVERLAPPED * ) & pPerIO, WSA_INFINITE);

         if ( ! bOK)     //  在此套接字上有错误发生
        {       
            ::closesocket(pPerHandle -> s);
            ::GlobalFree(pPerHandle);
            ::GlobalFree(pPerIO);
             continue ;
        }
        
         if (dwTrans  ==   0   &&                                  //  套接字被对方关闭
            (pPerIO -> nOperationType  ==  OP_READ  ||  pPerIO -> nOperationType  ==  OP_WRITE))     
        {
            ::closesocket(pPerHandle -> s);
            ::GlobalFree(pPerHandle);
            ::GlobalFree(pPerIO);
             continue ;
        }
        
         switch (pPerIO -> nOperationType)   //  通过per-I/O数据中的nOperationType域查看什么I/O请求完成了
        {
         case  OP_READ:  //  完成一个接收请求
            {
                pPerIO -> buf[dwTrans]  =   ' \0 ' ;
                printf(pPerIO  ->  buf);
                
                 //  继续投递接收I/O请求
                WSABUF buf;
                buf.buf  =  pPerIO -> buf ;
                buf.len  =  BUFFER_SIZE;
                pPerIO -> nOperationType  =  OP_READ;
                DWORD nFlags  =   0 ;
                
                ::WSARecv(pPerHandle -> s,  & buf,  1 ,  & dwTrans,  & nFlags,  & pPerIO -> ol, NULL);
            }
             break ;
         case  OP_WRITE:  //  本例中没有投递这些类型的I/O请求
         case  OP_ACCEPT:
             break ;
    }
    }

     return   0 ;
}

windows完成端口服务器的另一种实现
http://www.winu.cn/space-14160-do-blog-id-1072.html

http://hi.baidu.com/50254147/blog/item/d13552fba5b45a9c58ee9014.html
Windows完成端口(Completion Port)编程小结2010-01-25 15:05完成端口中ConnectEx的问题：

完成端口用于客户端时一定要注意，创建的SOCKET要先随便绑定一个端口(默认0自动分配也可)，然后再扔到完成端口中去，之后才可以ConnectEx，否则(不绑定)，ConnectEx会出现10022错误。同时，getpeername似乎对ConnectEx不支持，也可能有其他细节设置我暂时不知道，返回的远程地址是无效的(仅对于完成端口用于服务器accept回来的SOCKET有效，对用于客户的connet也有效)。不过对程序没有太大影响，既然是自己要主动连出去，远程地址当然自己早就心里明白了，自己保存一份即可，不必getpeername。备注:getsockname返回本地地址一直是有效的。

getpeername之所以取不到正确的内容，是因为ConnectEx返回后，socket相关的属性还没有更新（ConnectEx的特性所导致），你应该调用一下setsockopt更新socket的属性后再调用getpeername。参数是SOL_SOCKET和SO_UPDATE_CONNECT_CONTEXT。

When the ConnectEx function returns, the socket s is in the default state for a connected socket. The socket s does not enable previously set properties or options until SO_UPDATE_CONNECT_CONTEXT is set on the socket. Use the setsockopt function to set the SO_UPDATE_CONNECT_CONTEXT option.

For example:

err = setsockopt(s, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, NULL, 0);

完成端口与ACE框架：

平台不同，使用的ACE框架还是有所差别的。比如windows下面的服务器端，一般都用Proactor框架，配合各种异步操作，如ACE_Asynch_Acceptor/ACE_Asynch_Connector，因为Proactor内部实现是完成端口，在windows平台上，公认可以取得最好的性能。

如果你用Linux，服务器端推荐你使用Reactor框架+Dev_Poll_Reactor实现，这个实现使用了Epoll机制，性能很棒。

客户端，一般为了兼容性考虑，都用Reactor，当然，如果是在windows上面运行，默认实现是WFMO_Reactor。

IOCP（I/O completion port，I/O完成端口）是伸缩性最好的一种I/O模型。本章将具体讨论完成端口的概念和它的用法，讲述可伸缩性服务器的体系结构，最后结合实例介绍使用IOCP进行可伸缩服务器程序设计的过程。

4.1 完成端口I/O模型
当应用程序必须一次管理多个套接字时，完成端口模型提供了最好的系统性能。这个模型也提供了最好的伸缩性，它非常适合用来处理上百、上千个套接字。IOCP技术广泛应用于各种类型的高性能服务器，如Apache等。本节将结合一个简单的例子详细讨论它的用法。

4.1.1 什么是完成端口（completion port）对象
I/O完成端口是应用程序使用线程池处理异步I/O请求的一种机制。处理多个并发异步I/O请求时，使用I/O完成端口比在I/O请求时创建线程更快更有效。

I/O完成端口最初的设计是应用程序发出一些异步I/O请求，当这些请求完成时，设备驱动将把这些工作项目排序到完成端口，这样，在完成端口上等待的线程池便可以处理这些完成I/O。完成端口实际上是一个Windows I/O结构，它可以接收多种对象的句柄，如文件对象、套接字对象等。本节仅讲述使用完成端口模型管理套接字的方法。

4.1.2 使用IOCP的方法
1．创建完成端口对象
使用完成端口模型，首先要调用CreateIoCompletionPort函数创建一个完成端口对象，Winsock将使用这个对象为任意数量的套接字句柄管理I/O请求。函数定义如下：

HANDLE CreateIoCompletionPort(HANDLE FileHandle,

         HANDLE ExistingCompletionPort, ULONG_PTR CompletionKey, DWORD NumberOfConcurrentThreads);

在详细解释函数参数之前，笔者先介绍此函数的两个不同功能。

（1）创建一个完成端口对象。

（2）将一个或者多个文件句柄（这里是套接字句柄）关联到I/O完成端口对象。

最初创建完成端口对象时，唯一需要设置的参数是NumberOfConcurrentThreads，它定义了允许在完成端口上同时执行的线程的数量。理想情况下，我们希望每个处理器仅运行一个线程来为完成端口提供服务，以避免线程上下文切换。NumberOfConcurrentThreads为0表示系统允许的线程数量与处理器数量一样多。因此，可以简单的使用以下代码创建完成端口对象，取得标识完成端口的句柄。

HANDLE hCompletion = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);

2．I/O服务线程和完成端口
成功创建完成端口对象之后，便可以向这个对象关联套接字句柄了。在关联套接字之前，需要先创建一个或者多个工作线程（称为I/O服务线程），在完成端口上执行并处理投递到完成端口上的I/O请求。这里的关键问题是要创建多少个工作线程。要注意，创建完成端口时指定的线程数量和这里要创建的线程数量不是一回事。前面我们推荐线程数量为处理器的数量，以避免上下文切换。CreateIoCompletionPort 函数的NumberOfConcurrentThreads参数明确告诉系统允许在完成端口上同时运行的线程数量。如果创建的线程多于NumberOfConcurrent Threads，也就仅有NumberOfConcurrentThreads个线程允许运行。但是有的时候，确实需要创建更多的线程，这主要取决于程序的总体设计。如果某个线程调用了一个函数，如Sleep或WaitForSingleObject，进入了暂停状态，多出来的线程中就会有一个开始运行，占据休眠线程的位置。总而言之，我们总是希望在完成端口上参加I/O处理工作的线程和CreateIoCompletionPort函数指定的线程一样多。最后的结论是，如果你觉得工作线程会遇到阻塞（进入暂停状态），那就应该创建比CreateIoCompletionPort指定的数量还要多的线程。

有了足够的工作线程来处理完成端口上的I/O请求之后，就该为完成端口关联套接字句柄了，这就用到了CreateIoCompletionPort函数的前3个参数。

l          FileHandle                             要关联的套接字句柄

l          ExistingCompletionPort        上面创建的完成端口对象句柄

l          CompletionKey                     指定一个句柄唯一（per-handle）数据，它将与FileHandle套接字句柄                                              关联在一起。应用程序可以在此存储任意类型的信息，通常是一个指针

CompletionKey参数通常用来描述与套接字相关的信息，所以称它为句柄唯一（per-handle）数据。在后面的例子代码中，可以看到它的作用。

3．完成端口和重叠I/O
向完成端口关联套接字句柄之后，便可以通过在套接字上投递重叠发送和接收请求处理I/O了。在这些I/O操作完成时，I/O系统会向完成端口对象发送一个完成通知封包。I/O完成端口以先进先出的方式为这些封包排队。应用程序使用GetQueuedCompletionStatus函数可以取得这些队列中的封包。这个函数应该在处理完成对象I/O的服务线程中调用。

BOOL GetQueuedCompletionStatus(

HANDLE CompletionPort,                          // 完成端口对象句柄

LPDWORD lpNumberOfBytes,                  // 取得I/O操作期间传输的字节数

PULONG_PTR lpCompletionKey,             // 取得在关联套接字时指定的句柄唯一数据

LPOVERLAPPED* lpOverlapped,    // 取得投递I/O操作时指定的OVERLAPPED结构

DWORD dwMilliseconds // 如果完成端口没有完成封包，此参数指定了等待的事件，INFINITE为无穷大

);

I/O服务线程调用GetQueuedCompletionStatus函数取得有事件发生的套接字的信息，通过lpNumberOfBytes 参数得到传输的字节数量，通过lpCompletionKey参数得到与套接字关联的句柄唯一（per-handle）数据，通过lpOverlapped参数得到投递I/O请求时使用的重叠对象地址，进一步得到I/O唯一（per-I/O）数据。

这些参数中，最重要的是per-handle数据和per-I/O数据。

lpCompletionKey参数包含了我们称为per-handle的数据，因为当套接字第一次与完成端口关联时，这个数据就关联到了一个套接字句柄。这是传递给CreateIoCompletionPort函数的CompletionKey参数。如前所述，可以给这个参数传递任何类型的数据。

lpOverlapped参数指向一个OVERLAPPED结构，结构后面便是我们称为per-I/O的数据，这可以是工作线程处理完成封包时想要知道的任何信息。

4.1.3 示例程序
下面是一个简单的使用IOCP模型的TCP服务器例子，它仅打印出从客户端接收到的数据。后面还要在这个例子的基础上设计高性能、可伸缩的服务器类CIOCPServer。

例子中有两种类型的线程－主线程和它创建的线程。主线程创建监听套接字，创建额外的工作线程，关联IOCP，负责等待和接受到来的连接等。由主线程创建的线程负责处理I/O事件，这些线程调用GetQueuedCompletionStatus函数在完成端口对象上等待完成的I/O操作。

GetQueuedCompletionStatus函数返回后，说明发生了如下事件之一。

（1）GetQueuedCompletionStatus调用失败，说明在此套接字上有错误发生。

（2）BytesTransferred为0说明套接字被对方关闭。注意，per-handle数据用来引用与I/O操作相关的套接字。

（3）I/O请求成功完成。通过per-I/O数据（这是程序自定义的结构）中的OperationType域查看哪个I/O请求完成了。

程序首先定义了per-handle数据和per-I/O操作数据的结构类型。

// 初始化Winsock库

CInitSock theSock;

#define BUFFER_SIZE 1024

typedef struct _PER_HANDLE_DATA                   // per-handle数据

{

         SOCKET s;                           // 对应的套接字句柄

         sockaddr_in addr;                  // 客户方地址

} PER_HANDLE_DATA, *PPER_HANDLE_DATA;

typedef struct _PER_IO_DATA                      // per-I/O数据

{

         OVERLAPPED ol;                // 重叠结构

         char buf[BUFFER_SIZE];    // 数据缓冲区

         int nOperationType;             // 操作类型

#define OP_READ   1

#define OP_WRITE 2

#define OP_ACCEPT 3

} PER_IO_DATA, *PPER_IO_DATA;

主线程首先创建完成端口对象，创建工作线程处理完成端口对象中的事件；然后再创建监听套接字，开始监听服务端口；接下来便进入无限循环，处理到来的连接请求，这个过程如下：

（1）调用accept函数等待接受未决的连接请求。

（2）接受到新连接之后，为它创建一个per-handle数据，并将它们关联到完成端口对象。

（3）在新接受的套接字上投递一个接收请求。这个I/O完成之后，由工作线程负责处理。

下面是具体的实现代码。

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);

                   ::CreateIoCompletionPort((HANDLE)pPerHandle->s, hCompletion, (DWORD)pPerHandle, 0);

                   // 投递一个接收请求

                   PPER_IO_DATA pPerIO = (PPER_IO_DATA)::GlobalAlloc(GPTR, sizeof(PER_IO_DATA));

                   pPerIO->nOperationType = OP_READ;

                   WSABUF buf;

                   buf.buf = pPerIO->buf;

                   buf.len = BUFFER_SIZE;    

                   DWORD dwRecv;

                   DWORD dwFlags = 0;

                   ::WSARecv(pPerHandle->s, &buf, 1, &dwRecv, &dwFlags, &pPerIO->ol, NULL);

         }

}

I/O服务线程循环调用GetQueuedCompletionStatus函数从I/O完成端口移除完成的I/O封包，然后根据封包的类型进行处理。具体程序代码如下：

DWORD WINAPI ServerThread(LPVOID lpParam)

{       // 得到完成端口对象句柄

         HANDLE hCompletion = (HANDLE)lpParam;

         DWORD dwTrans;

         PPER_HANDLE_DATA pPerHandle;

         PPER_IO_DATA pPerIO;

         while(TRUE)

         {       // 在关联到此完成端口的所有套接字上等待I/O完成

                   BOOL bOK = ::GetQueuedCompletionStatus(hCompletion,

                            &dwTrans, (LPDWORD)&pPerHandle, (LPOVERLAPPED*)&pPerIO, WSA_INFINITE);

                   if(!bOK)                                                   // 在此套接字上有错误发生

                  {       ::closesocket(pPerHandle->s);

                            ::GlobalFree(pPerHandle);

                            ::GlobalFree(pPerIO);

                            continue;

                   }

                   if(dwTrans == 0 &&                                // 套接字被对方关闭

                            (pPerIO->nOperationType == OP_READ || pPerIO->nOperationType == OP_WRITE))    

                   {       ::closesocket(pPerHandle->s);

                            ::GlobalFree(pPerHandle);

                            ::GlobalFree(pPerIO);

                            continue;

                   }

                   switch(pPerIO->nOperationType) // 通过per-I/O数据中的nOperationType域查看什么I/O请求完成了

                   {

                   case OP_READ: // 完成一个接收请求

                            {       pPerIO->buf[dwTrans] = '\0';

                                     printf(pPerIO -> buf);

                                     // 继续投递接收I/O请求

                                     WSABUF buf;

                                     buf.buf = pPerIO->buf ;

                                     buf.len = BUFFER_SIZE;

                                     pPerIO->nOperationType = OP_READ;

                                     DWORD nFlags = 0;

                                     ::WSARecv(pPerHandle->s, &buf, 1, &dwTrans, &nFlags, &pPerIO->ol, NULL);

                            }

                            break;

                   case OP_WRITE: // 本例中没有投递这些类型的I/O请求

                   case OP_ACCEPT:

                            break;

                   }

         }

         return 0;

}

4.1.4 恰当地关闭IOCP
4.1.3小节的例子中没有涉及如何恰当地关闭I/O完成端口，特别是当有多个线程在套接字上执行I/O的时候。主要要避免的事情是当重叠操作正在进行的时候释放它的OVERLAPPED结构，阻止其发生的最好的方法是在每个套接字句柄上调用closesocket函数—所有未决的重叠I/O操作都会完成。一旦所有的套接字句柄关闭，就该终止完成端口上处理I/O的工作线程了。这可以通过使用PostQueuedCompletionStatus函数向工作线程发送特定的完成封包来实现，这个完成封包通知工作线程立即退出。PostQueuedCompletionStatus函数定义如下：

BOOL PostQueuedCompletionStatus(

HANDLE CompletionPort,                                             // 完成端口对象句柄

DWORD dwNumberOfBytesTransferred,           // 指定GetQueuedCompletionStatus函数的

                                                                                 // lpNumberOfBytesTransferred参数的返回值

ULONG_PTR dwCompletionKey,       // 指定GetQueuedCompletionStatus函数的lpCompletionKey参数的返回值

LPOVERLAPPED lpOverlapped         // 指定GetQueuedCompletionStatus函数的lpOverlapped参数的返回值

);

当工作线程接收到GetQueuedCompletionStatus的3个参数时，可以决定是否应该退出。例如，可以在向dwCompletionKey参数传递0，所有的工作线程都退出之后，可以使用CloseHandle关闭完成端口。

完成端口是到现在为止在性能和可伸缩性方面表现最好的I/O模型。关联到完成端口对象的套接字的数量并没有限制，仅需要少量的线程来处理完成I/O。本章后面将具体讨论如何使用完成端口开发可伸缩的高性能服务器程序。

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

Windows完成端口与Linux epoll技术简介
http://www.cnblogs.com/liuweijian/archive/2009/12/27/1633657.html
WINDOWS完成端口编程
1、基本概念
2、WINDOWS完成端口的特点
3、完成端口（Completion Ports ）相关数据结构和创建
4、完成端口线程的工作原理
5、Windows完成端口的实例代码
Linux的EPoll模型
1、为什么select落后
2、内核中提高I/O性能的新方法epoll
3、epoll的优点
4、epoll的工作模式
5、epoll的使用方法
6、Linux下EPOll编程实例
总结

WINDOWS完成端口编程
        摘要：开发网络程序从来都不是一件容易的事情，尽管只需要遵守很少的一些规则;创建socket,发起连接，接受连接，发送和接受数据。真正的困难在于：让你的程序可以适应从单单一个连接到几千个连接乃至于上万个连接。利用Windows平台完成端口进行重叠I/O的技术和Linux在2.6版本的内核中引入的EPOll技术，可以很方便在在在Windows和Linux平台上开发出支持大量连接的网络服务程序。本文介绍在Windows和Linux平台上使用的完成端口和EPoll模型开发的基本原理，同时给出实际的例子。本文主要关注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来操作，则必须设定为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、完成端口线程的工作原理
完成端口可以帮助我们管理线程池，但是线程池中的线程需要我们使用_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高级编程指南》，我们现在知道的知识，已经足够了。 完成端口线程间数据传递线程间传递数据最常用的办法是在_beginthreadex函数中将参数传递给线程函数，或者使用全局变量。但是完成端口还有自己的传递数据的方法，答案就在于CompletionKey和OVERLAPPED参数。
CompletionKey被保存在完成端口的设备表中，是和设备句柄一一对应的，我们可以将与设备句柄相关的数据保存到CompletionKey中，或者将CompletionKey表示为结构指针，这样就可以传递更加丰富的内容。这些内容只能在一开始关联完成端口和设备句柄的时候做，因此不能在以后动态改变。
OVERLAPPED参数是在每次调用ReadFile这样的支持重叠I/0的函数时传递给完成端口的。我们可以看到，如果我们不是对文件设备做操作，该结构的成员变量就对我们几乎毫无作用。我们需要附加信息，可以创建自己的结构，然后将OVERLAPPED结构变量作为我们结构变量的第一个成员，然后传递第一个成员变量的地址给ReadFile函数。因为类型匹配，当然可以通过编译。当GetQueuedCompletionStatus函数返回时，我们可以获取到第一个成员变量的地址，然后一个简单的强制转换，我们就可以把它当作完整的自定义结构的指针使用，这样就可以传递很多附加的数据了。太好了！只有一点要注意，如果跨线程传递，请注意将数据分配到堆上，并且接收端应该将数据用完后释放。我们通常需要将ReadFile这样的异步函数的所需要的缓冲区放到我们自定义的结构中，这样当GetQueuedCompletionStatus被返回时，我们的自定义结构的缓冲区变量中就存放了I/0操作的数据。CompletionKey和OVERLAPPED参数，都可以通过GetQueuedCompletionStatus函数获得。
线程的安全退出
       很多线程为了不止一次的执行异步数据处理，需要使用如下语句
while (true)
{
       ......
       GetQueuedCompletionStatus(...);
        ......
}
那么如何退出呢，答案就在于上面曾提到的PostQueudCompletionStatus函数，我们可以用它发送一个自定义的包含了OVERLAPPED成员变量的结构地址，里面包含一个状态变量，当状态变量为退出标志时，线程就执行清除动作然后退出。

5、Windows完成端口的实例代码：
DWORD WINAPI WorkerThread(LPVOID lpParam)
{
ULONG_PTR *PerHandleKey;
OVERLAPPED *Overlap;
OVERLAPPEDPLUS *OverlapPlus,
*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 PlatFormSDK，那里有完成端口的例子。访问http://msdn.microsoft.com/library/techart/msdn_servrapp.htm可以获得更多信息。

Linux的EPoll模型
Linux 2.6内核中提高网络I/O性能的新方法-epoll I/O多路复用技术在比较多的TCP网络服务器中有使用，即比较多的用到select函数。

1、为什么select落后
首先，在Linux内核中，select所用到的FD_SET是有限的，即内核中有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数，在我用的2.6.15-25-386内核中，该值是1024，搜索内核源代码得到：
include/linux/posix_types.h:#define __FD_SETSIZE         1024
也就是说，如果想要同时检测1025个句柄的可读状态是不可能用select实现的。或者同时检测1025个句柄的可写状态也是不可能的。其次，内核中实现select是用轮询方法，即每次检测都会遍历所有FD_SET中的句柄，显然，select函数执行时间与FD_SET中的句柄个数有一个比例关系，即select要检测的句柄数越多就会越费时。当然，在前文中我并没有提及poll方法，事实上用select的朋友一定也试过poll，我个人觉得select和poll大同小异，个人偏好于用select而已。

2、内核中提高I/O性能的新方法epoll
epoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll。要使用epoll只需要这三个系统调用：epoll_create(2)， epoll_ctl(2)， epoll_wait(2)。
当然，这不是2.6内核才有的，它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)

Linux2.6内核epoll介绍
先介绍2本书《The Linux Networking Architecture--Design and Implementation of Network Protocols in the Linux Kernel》，以2.4内核讲解Linux TCP/IP实现，相当不错.作为一个现实世界中的实现，很多时候你必须作很多权衡，这时候参考一个久经考验的系统更有实际意义。举个例子,linux内核中sk_buff结构为了追求速度和安全，牺牲了部分内存，所以在发送TCP包的时候，无论应用层数据多大,sk_buff最小也有272的字节.其实对于socket应用层程序来说，另外一本书《UNIX Network Programming Volume 1》意义更大一点.2003年的时候，这本书出了最新的第3版本，不过主要还是修订第2版本。其中第6章《I/O Multiplexing》是最重要的。Stevens给出了网络IO的基本模型。在这里最重要的莫过于select模型和Asynchronous I/O模型.从理论上说，AIO似乎是最高效的，你的IO操作可以立即返回，然后等待os告诉你IO操作完成。但是一直以来，如何实现就没有一个完美的方案。最著名的windows完成端口实现的AIO,实际上也是内部用线程池实现的罢了，最后的结果是IO有个线程池，你应用也需要一个线程池...... 很多文档其实已经指出了这带来的线程context-switch带来的代价。在linux 平台上，关于网络AIO一直是改动最多的地方，2.4的年代就有很多AIO内核patch,最著名的应该算是SGI那个。但是一直到2.6内核发布，网络模块的AIO一直没有进入稳定内核版本(大部分都是使用用户线程模拟方法，在使用了NPTL的linux上面其实和windows的完成端口基本上差不多了)。2.6内核所支持的AIO特指磁盘的AIO---支持io_submit(),io_getevents()以及对Direct IO的支持(就是绕过VFS系统buffer直接写硬盘，对于流服务器在内存平稳性上有相当帮助)。
所以，剩下的select模型基本上就是我们在linux上面的唯一选择，其实，如果加上no-block socket的配置，可以完成一个"伪"AIO的实现，只不过推动力在于你而不是os而已。不过传统的select/poll函数有着一些无法忍受的缺点，所以改进一直是2.4-2.5开发版本内核的任务，包括/dev/poll，realtime signal等等。最终，Davide Libenzi开发的epoll进入2.6内核成为正式的解决方案

3、epoll的优点
<1>支持一个进程打开大数目的socket描述符(FD)
select 最不能忍受的是一个进程所打开的FD是有一定限制的，由FD_SETSIZE设置，默认值是2048。对于那些需要支持的上万连接数目的IM服务器来说显然太少了。这时候你一是可以选择修改这个宏然后重新编译内核，不过资料也同时指出这样会带来网络效率的下降，二是可以选择多进程的解决方案(传统的Apache方案)，不过虽然linux上面创建进程的代价比较小，但仍旧是不可忽视的，加上进程间数据同步远比不上线程间同步的高效，所以也不是一种完美的方案。不过 epoll则没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。
<2>IO效率不随FD数目增加而线性下降
传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合，不过由于网络延时，任一时间只有部分的socket是"活跃"的，但是select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，它只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数，其他idle状态socket则不会，在这点上，epoll实现了一个"伪"AIO，因为这时候推动力在os内核。在一些 benchmark中，如果所有的socket基本上都是活跃的---比如一个高速LAN环境，epoll并不比select/poll有什么效率，相反，如果过多使用epoll_ctl,效率相比还有稍微的下降。但是一旦使用idle connections模拟WAN环境,epoll的效率就远在select/poll之上了。
<3>使用mmap加速内核与用户空间的消息传递。
这点实际上涉及到epoll的具体实现了。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。而如果你想我一样从2.5内核就关注epoll的话，一定不会忘记手工 mmap这一步的。
<4>内核微调
这一点其实不算epoll的优点了，而是整个linux平台的优点。也许你可以怀疑linux平台，但是你无法回避linux平台赋予你微调内核的能力。比如，内核TCP/IP协议栈使用内存池管理sk_buff结构，那么可以在运行时期动态调整这个内存pool(skb_head_pool)的大小--- 通过echo XXXX>/proc/sys/net/core/hot_list_length完成。再比如listen函数的第2个参数(TCP完成3次握手的数据包队列长度)，也可以根据你平台内存大小动态调整。更甚至在一个数据包面数目巨大但同时每个数据包本身大小却很小的特殊系统上尝试最新的NAPI网卡驱动架构。
4、epoll的工作模式
令人高兴的是，2.6内核的epoll比其2.5开发版本的/dev/epoll简洁了许多，所以，大部分情况下，强大的东西往往是简单的。唯一有点麻烦是epoll有2种工作方式:LT和ET。
LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表．
ET (edge-triggered)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once),不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认。
epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用，具体用法请参考http://www.xmailserver.org/linux-patches/nio-improve.html ，在http://www.kegel.com/rn/也有一个完整的例子，大家一看就知道如何使用了
Leader/follower模式线程pool实现，以及和epoll的配合。

5、 epoll的使用方法
    首先通过create_epoll(int maxfds)来创建一个epoll的句柄，其中maxfds为你epoll所支持的最大句柄数。这个函数会返回一个新的epoll句柄，之后的所有操作将通过这个句柄来进行操作。在用完之后，记得用close()来关闭这个创建出来的epoll句柄。 之后在你的网络主循环里面，每一帧的调用epoll_wait(int epfd, epoll_event events, int max events, int timeout)来查询所有的网络接口，看哪一个可以读，哪一个可以写了。基本的语法为：
nfds = epoll_wait(kdpfd, events, maxevents, -1);
其中kdpfd为用epoll_create创建之后的句柄，events是一个epoll_event*的指针，当epoll_wait这个函数操作成功之后，epoll_events里面将储存所有的读写事件。max_events是当前需要监听的所有socket句柄数。最后一个timeout是epoll_wait的超时，为0的时候表示马上返回，为-1的时候表示一直等下去，直到有事件范围，为任意正整数的时候表示等这么长的时间，如果一直没有事件，则范围。一般如果网络主循环是单独的线程的话，可以用-1来等，这样可以保证一些效率，如果是和主逻辑在同一个线程的话，则可以用0来保证主循环的效率。

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

对，epoll的操作就这么简单，总共不过4个API：epoll_create, epoll_ctl, epoll_wait和close。
如果您对epoll的效率还不太了解，请参考我之前关于网络游戏的网络编程等相关的文章。

以前公司的服务器都是使用HTTP连接，但是这样的话，在手机目前的网络情况下不但显得速度较慢，而且不稳定。因此大家一致同意用SOCKET来进行连接。虽然使用SOCKET之后，对于用户的费用可能会增加(由于是用了CMNET而非CMWAP)，但是，秉着用户体验至上的原则，相信大家还是能够接受的(希望那些玩家月末收到帐单不后能够保持克制...)。
这次的服务器设计中，最重要的一个突破，是使用了EPOLL模型，虽然对之也是一知半解，但是既然在各大PC网游中已经经过了如此严酷的考验，相信他不会让我们失望，使用后的结果，确实也是表现相当不错。在这里，我还是主要大致介绍一下这个模型的结构。
6、Linux下EPOll编程实例
EPOLL模型似乎只有一种格式，所以大家只要参考我下面的代码，就能够对EPOLL有所了解了，代码的解释都已经在注释中：

while (TRUE)
{
int nfds = epoll_wait (m_epoll_fd, m_events, MAX_EVENTS, EPOLL_TIME_OUT);//等待EPOLL时间的发生，相当于监听，至于相关的端口，需要在初始化EPOLL的时候绑定。
if (nfds <= 0)
continue;
m_bOnTimeChecking = FALSE;
G_CurTime = time(NULL);
for (int i=0; i
{
try
{
if (m_events[i].data.fd == m_listen_http_fd)//如果新监测到一个HTTP用户连接到绑定的HTTP端口，建立新的连接。由于我们新采用了SOCKET连接，所以基本没用。
{
OnAcceptHttpEpoll ();
}
else if (m_events[i].data.fd == m_listen_sock_fd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
{
OnAcceptSockEpoll ();
}
else if (m_events[i].events & EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入。
{
OnReadEpoll (i);
}

OnWriteEpoll (i);//查看当前的活动连接是否有需要写出的数据。
}
catch (int)
{
PRINTF ("CATCH捕获错误\n");
continue;
}
}
m_bOnTimeChecking = TRUE;
OnTimer ();//进行一些定时的操作，主要就是删除一些短线用户等。
}
　其实EPOLL的精华，也就是上述的几段短短的代码，看来时代真的不同了，以前如何接受大量用户连接的问题，现在却被如此轻松的搞定，真是让人不得不感叹，对哪。

总结
Windows完成端口与Linux epoll技术方案是这2个平台上实现异步IO和设计开发一个大容量，具可扩展性的winsock程序指服务程序的很好的选择，本文对这2中技术的实现原理和实际的使用方法做了一个详细的介绍。

 

Windows完成端口编程
http://blog.chinaunix.net/u1/33885/showart_272181.html

一 基本概念
二 OVERLAPPED数据结构
三 完成端口的内部机制
创建完成端口
完成端口线程的工作原理
线程间数据传递
线程的安全退出

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

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

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

重叠I/O需要使用的一个非常重要的数据结构OVERLAPPED。

       完成端口---是一种WINDOWS内核对象。完成端口用于异步方式的重叠I/0情况下，当然重叠I/O不一定非使用完成端口不可，还有设备内核对象、事件对象、告警I/0等。但是完成端口内部提供了线程池的管理，可以避免反复创建线程的开销，同时可以根据CPU的个数灵活的决定线程个数，而且可以让减少线程调度的次数从而提高性能。

 

 

二 OVERLAPPED数据结构
typedef struct _OVERLAPPED {

 

    ULONG_PTR Internal;//被系统内部赋值，用来表示系统状态

 

    ULONG_PTR InternalHigh;// 被系统内部赋值，传输的字节数

 

    union {

 

        struct {

 

            DWORD Offset;//和OffsetHigh合成一个64位的整数，用来表示从文件头部的多少字节开始

 

            DWORD OffsetHigh;//操作，如果不是对文件I/O来操作，则必须设定为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值。

 

 

 

 

 

三 完成端口的内部机制
创建完成端口

       完成端口是一个内核对象，使用时他总是要和至少一个有效的设备句柄进行关联，完成端口是一个复杂的内核对象，创建它的函数是：

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的个数来自动确定。

 

 

创建和关联的动作完成后，系统会将完成端口关联的设备句柄、完成键作为一条纪录加入到这个完成端口的设备列表中。如果你有多个完成端口，就会有多个对应的设备列表。如果设备句柄被关闭，则表中自动删除该纪录。

 

 

 

 

 

完成端口线程的工作原理

       完成端口可以帮助我们管理线程池，但是线程池中的线程需要我们使用_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高级编程指南》，我们现在知道的知识，已经足够了。

 

   

 

线程间数据传递

       线程间传递数据最常用的办法是在_beginthreadex函数中将参数传递给线程函数，或者使用全局变量。但是完成端口还有自己的传递数据的方法，答案就在于CompletionKey和OVERLAPPED参数。

CompletionKey被保存在完成端口的设备表中，是和设备句柄一一对应的，我们可以将与设备句柄相关的数据保存到CompletionKey中，或者将CompletionKey表示为结构指针，这样就可以传递更加丰富的内容。这些内容只能在一开始关联完成端口和设备句柄的时候做，因此不能在以后动态改变。

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

 

CompletionKey和OVERLAPPED参数，都可以通过GetQueuedCompletionStatus函数获得。

线程的安全退出

       很多线程为了不止一次的执行异步数据处理，需要使用如下语句

while (true)

{

       .。。。。。。

       GetQueuedCompletionStatus(...);

 

              。。。。。。

}

那么如何退出呢，答案就在于上面曾提到的PostQueudCompletionStatus函数，我们可以用它发送一个自定义的包含了OVERLAPPED成员变量的结构地址，里面包含一个状态变量，当状态变量为退出标志时，线程就执行清除动作然后退出。