win socket 模型詳解 （轉）

《轉：http://www.cppblog.com/changshoumeng/articles/113441.html 》

Socket模型詳解

兩種Socket模式

一.選擇模型

二.異步選擇

三.事件選擇

四.重疊I/O模型

五.完成端口模型

五種I/O模型的比較

 

 

 

兩種Socket模式

1、 兩種Socket模式

阻塞模式：執行I/O操做完成前會一直進行等待，不會將控制權交給程序。套接字默認爲阻塞模式。能夠經過多線程技術進行處理。

非阻塞模式：執行I/O操做時，Winsock函數會返回並交出控制權。這種模式使用起來比較複雜，由於函數在沒有運行完成就進行返回，會不斷地返回 WSAEWOULDBLOCK錯誤。但功能強大。

 

若是你想在Windows平臺上構建服務器應用，那麼I/O模型是你必須考慮的。Windows操做系統提供了選擇（Select）、異步選擇（WSAAsyncSelect）、事件選擇（WSAEventSelect）、重疊I/O（Overlapped I/O）和完成端口（Completion Port)共五種I/O模型。每一種模型均適用於一種特定的應用場景。程序員應該對本身的應用需求很是明確，並且綜合考慮到程序的擴展性和可移植性等因素，做出本身的選擇。

 

我會以一個迴應反射式服務器（與《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服務器的代碼（已經不能再精簡了）：

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);//將fdread初始化空集

    for (i = 0; i < g_iTotalConn; i++)

    {

      FD_SET(g_CliSocketArr, &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, &fdread))//若是可讀

      {

        // A read event happened on g_CliSocketArr

        ret = recv(g_CliSocketArr, szMessage, MSGSIZE, 0);

    if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))

    {

     // Client socket closed

          printf("Client socket %d closed.\n", g_CliSocketArr);

     closesocket(g_CliSocketArr);

     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, 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%。

 

關係到套接字列表的操做都須要使用循環,在輪詢的時候,須要遍歷一次,再新的一輪開始時,將列表加入隊列又須要遍歷一次.也就是說,Select在工做一次時,須要至少遍歷2次列表,這是它效率較低的緣由之一.在大規模的網絡鏈接方面,仍是推薦使用IOCP或EPOLL模型.可是Select模型可使用在諸如對戰類遊戲上,好比相似星際這種,由於它小巧易於實現,並且對戰類遊戲的網絡鏈接量並不大.

 

對於Select模型想要突破Windows 64個限制的話,能夠採起分段輪詢,一次輪詢64個.例如套接字列表爲128個,在第一次輪詢時,將前64個放入隊列中用Select進行狀態查詢,待本次操做所有結束後.將後64個再加入輪詢隊列中進行輪詢處理.這樣處理須要在非阻塞式下工做.以此類推,Select也能支持無限多個.

 

 

二.異步選擇

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, //T，都進纔回；F，一進就回

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

//處理FD-READ網絡事件

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

      }

    }

    //處理FD-CLOSE網絡事件

    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<完成端口