Chinaunix首页 | 论坛 | 博客

蝈蝈的足迹

首页　| 　博文目录　| 　关于我

renjian2011

  • 博客访问： 244025
  • 博文数量： 62
  • 博客积分： 973
  • 博客等级： 准尉
  • 技术积分： 530
  • 用 户 组： 普通用户
  • 注册时间： 2011-11-16 23:25
文章分类

全部博文（62）

文章存档

2013年（1）

2012年（14）

2011年（47）

我的朋友
最近访客
推荐博文
相关博文
完成端口简介

分类： C/C++

2011-12-04 22:24:16

amy3701229所理解的完成端口原理是:创建一个完成端口与一个SOCKET绑定,所有通过该SOCKET通讯的数据都由完成端口机制来处理,完成端口是异步I/O,接收和发送都是提交后不管结果,所有结果都由完成端口的消息机制来做相应的通知,并且完成端口内部有线程池的概念
 
//www.cnblogs.com/jiayongzhi/archive/2011/05/17/2048286.html

首先来说为什么要使用完成端口：

原因还是因为为了解决recv方法为阻塞式的问题，WinSocket封装的WSARecv方法为非堵塞的方法。

int WSARecv(

SOCKET lpCompletionRoutine

);

WSARecv为非阻塞的方法，其中第二个参数是I/O请求成功时，数据保存的地址。

Socket的触发是属于网卡硬件的中断信号，只是此信号CPU不能直接获取状态，此时我们可以使之绑定Event事件，Event内核对象的状态时可以监听到的。

这也就是WSAEventSelect模型的原理，当然重叠模型的最终原理也是如此。但Event的方法有着其弊病：当模型处理多线程事件时要调用WSAWaitForMultipleEvents函数，

WSAWaitForMultipleEvents函数一次最多只能等待64个事件对象。所以当海量客户端连接服务器时，服务器将没有能力应对，于是我们使用完成端口。

完成端口：

HANDLE CreateIoCompletionPort(

    HANDLE FileHandle, //要链接的Socket

    HANDLE ExistingCompletionPort, //全局完成端口

//同完成端口关联到一起的句柄，此处可为链接的socket，或是id等等（目地使接收到的socket知道是哪个socket）

    DWORD CompletionKey,

    DWORD NumberOfConcurrentThreads

);

此函数创建创建Socket与完成端口的链接，CreateIoCompletionPort函数被用于完成两个工作：

  • 用于创建—个完成端口对象。
  • 将一个句柄同完成端口关联到一起。

用函数GetQueuedCompletionStatus等待全局完成端口的完成队列。 

BOOL GetQueuedCompletionStatus(
    
    HANDLE                CompletionPort,

    LPDWORD               lpNumberOfBytes,

    PULONG_PTR        lpCompletionKey,  //此参数为CreateIoCompletionPort第三个参数传过来的句柄,通过此参数获得socket
     
    LPOVERLAPPED*         lpOverlapped,

    DWORD                dwMilliseconds

);   

完成端口的工作原理是，把Socket和完成端口绑定，通过关联句柄传递传递参数，使得获取到的Socket能得知是那个socket，参数可以自定义可以是socket本身也可以是id等等。

  1. #include "WinSock2.h"

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


  6. #define MESSAGESIZE 1024

  8. SOCKET serverSocket;

  10. DWORD WINAPI SocketProcAccept(LPVOID pParam);

  12. DWORD WINAPI SocketProcMain(LPVOID pParam);

  14. enum SOCKETOPERATE
  15. {
  16.     soREVC
  17. };

  19. struct SOCKETDATA
  20. {

  22.     WSAOVERLAPPED overlapped;

  24.     WSABUF buf;

  26.     char sMessage[MESSAGESIZE];

  28.     DWORD dwBytes;

  30.     DWORD flag;

  32.     SOCKETOPERATE socketType;

  34.     void Clear(SOCKETOPERATE type)
  35.     {
  36.         ZeroMemory(this, sizeof(SOCKETDATA));

  38.         buf.buf = sMessage;

  40.         buf.len = MESSAGESIZE;

  42.         socketType = type;
  43.     }
  44. };

  46. SOCKET CreateServiceSocket(int Port)
  47. {

  49.     int iError;

  51.     WSAData data;

  53.     iError = WSAStartup(0x0202, &data);

  55.     SOCKET tmp = socket(AF_INET,SOCK_STREAM,0);

  57.     if(tmp == INVALID_SOCKET)
  58.     {
  59.         return INVALID_SOCKET;
  60.     }

  62.     SOCKADDR_IN addr;

  64.     addr.sin_addr.s_addr = inet_addr("127.0.0.1");

  66.     addr.sin_family = AF_INET;

  68.     addr.sin_port = htons(Port);

  70.     if((bind(tmp, (sockaddr*)&addr, sizeof(addr))) != 0)
  71.     {
  72.         closesocket(tmp);

  74.         return INVALID_SOCKET;
  75.     }

  77.     if((listen(tmp, INFINITE)) != 0)
  78.     {
  79.         closesocket(tmp);

  81.         return INVALID_SOCKET;
  82.     }
  83.     return tmp;
  84. }

  86. int _tmain(int argc, _TCHAR* argv[])
  87. {
  88.     HANDLE CP = INVALID_HANDLE_VALUE;

  90.     CP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);

  92.     SYSTEM_INFO systemInfo;

  94.     GetSystemInfo(&systemInfo);

  96.     for (int i = 0; i<systemInfo.dwNumberOfProcessors; i++)
  97.     {
  98.         CreateThread(NULL, NULL, &SocketProcMain, CP, NULL, NULL);
  99.     }

  101.     serverSocket = CreateServiceSocket(6565);

  103.     if (serverSocket == INVALID_SOCKET)
  104.     {
  105.         return 0;
  106.     }

  108.     CreateThread(NULL, NULL, &SocketProcAccept, CP, NULL, NULL);

  110.     while(1)
  111.     {
  112.         Sleep(10000);
  113.     }

  115.     CloseHandle(CP);

  117.     closesocket(serverSocket);

  119.     WSACleanup();

  121.     return 0;
  122. }

  124. DWORD WINAPI SocketProcAccept(LPVOID pParam)
  125. {
  126.     HANDLE CP = (HANDLE)pParam;

  128.     SOCKADDR_IN addr;

  130.     int len = sizeof(SOCKADDR_IN);

  132.     SOCKET tmp;

  134.     SOCKETDATA *lpSocketData;

  136.     while(1)
  137.     {
  138.         tmp = accept(serverSocket, (sockaddr*)&addr, &len);

  140.         printf("Client Accept:%s\t:%d\n", inet_ntoa(addr.sin_addr), htons(addr.sin_port));

  142.         CreateIoCompletionPort((HANDLE)tmp, CP, (DWORD)tmp, INFINITE);

  144.         lpSocketData = (SOCKETDATA *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SOCKETDATA));

  146.         lpSocketData->Clear(soREVC);

  148.         WSARecv(tmp, &lpSocketData->buf, 1,&lpSocketData->dwBytes, &lpSocketData->flag, &lpSocketData->overlapped, NULL);
  149.     }
  150. }

  152. DWORD WINAPI SocketProcMain(LPVOID pParam)
  153. {
  154.     HANDLE CP = (HANDLE)pParam;

  156.     SOCKADDR_IN addr;

  158.     DWORD dwBytes;

  160.     SOCKETDATA *lpSocketData;

  162.     SOCKET clientSocket;
  163.     
  164.     while(1)
  165.     {
  166.         GetQueuedCompletionStatus(CP, &dwBytes, (PULONG_PTR)&clientSocket, (LPOVERLAPPED*)&lpSocketData, INFINITE);

  168.         if(dwBytes == 0xFFFFFFFF)
  169.         {
  170.             return 0;
  171.         }

  173.         if(lpSocketData->socketType == soREVC)
  174.         {
  175.             if(dwBytes == 0)
  176.             {

  178.                 closesocket(clientSocket);

  180.                 HeapFree(GetProcessHeap(), 0, lpSocketData);

  182.             }else
  183.             {

  185.                 lpSocketData->sMessage[dwBytes] = '\0';

  187.                 printf("%x\t:%s\n", (DWORD)clientSocket, lpSocketData->sMessage);

  189.                 lpSocketData->Clear(soREVC);

  191.                 WSARecv(clientSocket, &lpSocketData->buf, 1, &lpSocketData->dwBytes, &lpSocketData->flag, &lpSocketData->overlapped, NULL);

  193.             }

  195.         }

  197.     }
  198. }

Socket 重叠I/O 完成端口模型详解

//blog.sina.com.cn/s/blog_3fb7f7270100fesw.html

 

  1. 2009年02月23日 星期一 下午 10:07
  2. #include "stdafx.h"

  4. #include <WINSOCK2.h>
  5. #include <stdio.h>

  7. #define PORT 5150
  8. #define MSGSIZE 1024

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

  12. typedef enum
  13. {
  14.    RECV_POSTED
  15. }OPERATION_TYPE; //枚举,表示状态

  17. typedef struct
  18. {
  19. WSAOVERLAPPED overlap;
  20. WSABUF Buffer;
  21.    char szMessage[MSGSIZE];
  22. DWORD NumberOfBytesRecvd;
  23. DWORD Flags;
  24. OPERATION_TYPE OperationType;
  25. }PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA; //定义一个结构体保存IO数据

  27. DWORD WINAPI WorkerThread(LPVOID);

  29. int main()
  30. {
  31.    WSADATA wsaData;
  32.    SOCKET sListen, sClient;
  33.    SOCKADDR_IN local, client;
  34.    DWORD i, dwThreadId;
  35.    int iaddrSize = sizeof(SOCKADDR_IN);
  36.    HANDLE CompletionPort = INVALID_HANDLE_VALUE;
  37.    SYSTEM_INFO systeminfo;
  38.    LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

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

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

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

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

  56.    // 绑定套接字
  57.    local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
  58. local.sin_family = AF_INET;
  59. local.sin_port = htons(PORT);
  60.    bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  62.    // 开始监听！
  63.    listen(sListen, 3);

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

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


  95. //posts an I/O completion packet to an I/O completion port.
  96.    PostQueuedCompletionStatus(CompletionPort, 0xFFFFFFFF, 0, NULL);
  97. CloseHandle(CompletionPort);
  98. closesocket(sListen);
  99. WSACleanup();
  100. return 0;
  101. }
  102. //工作者线程有一个参数，是指向完成端口的句柄
  103. DWORD WINAPI WorkerThread(LPVOID CompletionPortID)
  104. {
  105.    HANDLE CompletionPort=(HANDLE)CompletionPortID;
  106.    DWORD dwBytesTransferred;
  107.    SOCKET sClient;
  108.    LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

  110.    while (TRUE)
  111.    {
  112.      GetQueuedCompletionStatus( //遇到可以接收数据则返回，否则等待
  113.        CompletionPort,
  114.        &dwBytesTransferred, //返回的字数
  115.     (PULONG_PTR&)sClient, //是响应的哪个客户套接字？
  116.        (LPOVERLAPPED *)&lpPerIOData, //得到该套接字保存的IO信息
  117.        INFINITE); //无限等待咯。不超时的那种。
  118.      if (dwBytesTransferred == 0xFFFFFFFF)
  119.      {
  120.        return 0;
  121.      }
  122.    
  123.      if (lpPerIOData->OperationType == RECV_POSTED) //如果受到数据
  124.      {
  125.        if (dwBytesTransferred == 0)
  126.        {
  127.          // Connection was closed by client
  128.          closesocket(sClient);
  129.          HeapFree(GetProcessHeap(), 0, lpPerIOData); //释放结构体
  130.        }
  131.        else
  132.        {
  133.          lpPerIOData->szMessage[dwBytesTransferred] = '\0';
  134.          send(sClient, lpPerIOData->szMessage, dwBytesTransferred, 0); //将接收到的消息返回
  135.        
  136.          // Launch another asynchronous operation for sClient
  137.          memset(lpPerIOData, 0, sizeof(PER_IO_OPERATION_DATA));
  138.          lpPerIOData->Buffer.len = MSGSIZE;
  139.          lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
  140.          lpPerIOData->OperationType = RECV_POSTED;
  141.          WSARecv(sClient, //循环接收
  142.     &lpPerIOData->Buffer,
  143.     1,
  144.     &lpPerIOData->NumberOfBytesRecvd,
  145.     &lpPerIOData->Flags,
  146.     &lpPerIOData->overlap,
  147.     NULL);
  148.        }
  149.      }
  150.    }
  151.    return 0;
  152. }

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

在工作者线程的循环中，我们
1.调用GetQueuedCompletionStatus取得本次I/O的相关信息（例如套接字句柄、传送的字节数、单I/O数据结构的地址等等）
2.通过单I/O数据结构找到接收数据缓冲区，然后将数据原封不动的发送到客户端
3.再次触发一个WSARecv异步操作

自己的理解，有任何问题都可以与我联系

 

阅读(2999) | 评论(0) | 转发(0) |
0

上一篇：C语言编译全过程

下一篇：深拷贝与浅拷贝

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6