@Koven.Z

#include "stdafx.h"

#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;    //定义一个结构体保存IO数据

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

   // 初始化完成端口
   CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);

   // 有几个CPU就创建几个工作者线程
   GetSystemInfo(&systeminfo);
   for (i = 0; i < systeminfo.dwNumberOfProcessors; i++)
   {
     CreateThread(NULL, 0, WorkerThread, CompletionPort, 0, &dwThreadId);
   }

   // 创建套接字
   sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

   // 绑定套接字
   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(sListen, 3);

   while (TRUE)//主进程的这个循环中循环等待客户端连接，若有连接，则将该客户套接字于完成端口绑定到一起
      //然后开始异步等待接收客户传来的数据。
   {
     // 如果接到客户请求连接，则继续，否则等待。
     sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
//client中保存用户信息。
     printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

//将这个最新到来的客户套接字和完成端口绑定到一起。
     CreateIoCompletionPort((HANDLE)sClient, CompletionPort, ( ULONG_PTR)sClient, 0);
//第三个参数表示传递的参数，这里就传递的客户套接字地址。最后一个参数为0 表示有和CPU一样的进程数。即1个CPU一个线程
   
     // 初始化结构体
     lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
       GetProcessHeap(),
       HEAP_ZERO_MEMORY,
       sizeof(PER_IO_OPERATION_DATA));
     lpPerIOData->Buffer.len = MSGSIZE; // len=1024
     lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
     lpPerIOData->OperationType = RECV_POSTED; //操作类型
     WSARecv(sClient,         //异步接收消息，立刻返回。
       &lpPerIOData->Buffer, //获得接收的数据
       1,       //The number of WSABUF structures in the lpBuffers array.
       &lpPerIOData->NumberOfBytesRecvd, //接收到的字节数，如果错误返回0
       &lpPerIOData->Flags,       //参数，先不管
       &lpPerIOData->overlap,     //输入这个结构体咯。
       NULL);
   }

//posts an I/O completion packet to an I/O completion port.
   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, //返回的字数
    (PULONG_PTR&)sClient,           //是响应的哪个客户套接字？
       (LPOVERLAPPED *)&lpPerIOData, //得到该套接字保存的IO信息
       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异步操作

自己的理解，有任何问题都可以留言或者于我联系