zoukankan      html  css  js  c++  java

  • Overlapped I/O模型--事件通知【摘录自《Windows网络编程》】

     
    重叠I / O的事件通知方法要求将Wi n 3 2事件对象与W S A O V E R L A P P E D结构关联在一起。若使用一个W S A O V E R L A P P E D结构，发出像W S A S e n d和W S A R e c v这样的I / O调用，它们会立即返回。

        一个重叠I / O请求最终完成后，我们的应用程序要负责取回重叠I / O操作的结果。一个重叠请求操作最终完成之后，在事件通知方法中， Wi n s o c k会更改与一个W S A O V E R L A P P E D结构对应的一个事件对象的事件传信状态，将其从“未传信”变成“已传信”。 由于一个事件对象

    已分配给W S A O V E R L A P P E D结构，所以只需简单地调用W S AWa i t F o r M u l t i p l e E v e n t s函数，从而判断出一个重叠I / O调用在什么时候完成。

       注意： W S AWa i t F o r M u l t i p l e E v e n t s返回只是说明重叠IO操作完成，但是是成功的完成还是失败的完成还要调用W S A G e t O v e r l a p p e dR e s u l t（取得重叠结构）函数

        如W S A G e t O v e r l a p p e d R e s u l t函数调用成功，返回值就是T R U E。这意味着我们的重叠I / O操作已成功完成，而且由l p c b Tr a n s f e r参数指向的值已进行了更新。

     

       我们向大家阐述了如何编制一个简单的服务器应用，令其在一个套接字上对重叠I / O操作进行管理，程序完全利用了前述的事件通知机制。对该程序采用的编程步骤总结如下：
    1) 创建一个套接字，开始在指定的端口上监听连接请求。
    2) 接受一个进入的连接请求。
    3) 为接受的套接字新建一个W S A O V E R L A P P E D结构，并为该结构分配一个事件对象句柄。也将事件对象句柄分配给一个事件数组，以便稍后由W S AWa i t F o r M u l t i p l e E v e n t s函数使用。
    4) 在套接字上投递一个异步W S A R e c v请求，指定参数为W S A O V E R L A P P E D结构。
    注意函数通常会以失败告终，返回S O C K E T _ E R R O R错误状态W S A _ I O _ P E N D I N G
    （I/O操作尚未完成）。
    5) 使用步骤3 )的事件数组，调用W S AWa i t F o r M u l t i p l e E v e n t s函数，并等待与重叠调用关联在一起的事件进入“已传信”状态（换言之，等待那个事件的“触发”）。
    6) WSAWa i t F o r M u l t i p l e E v e n t s函数完成后，针对事件数组，调用W S A R e s e t E v e n t（重设事件）函数，从而重设事件对象，并对完成的重叠请求进行处理。
    7) 使用W S A G e t O v e r l a p p e d R e s u l t函数，判断重叠调用的返回状态是什么。
    8) 在套接字上投递另一个重叠W S A R e c v请求。

    9) 重复步骤5 ) ~ 8 )。


    点击(此处)折叠或打开

    1. #include "stdafx.h"
    2.  #include <winsock2.h>

    4.  #define DATA_BUFSIZE 4096

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

    8.  int _tmain(int argc, _TCHAR* argv[])
    9.  {
    10.      DWORD EventTotal = 0,RecvBytes = 0, Flags = 0;
    11.      char buffer[DATA_BUFSIZE];

    13.      WSABUF DataBuf;
    14.      WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];
    15.      WSAOVERLAPPED AcceptOverlapped;
    16.      SOCKET Listen,Accept;

    18.      //step1:
    19.      //start Winsock and set up a listening socket
    20.      WSADATA wsaData;
    21.      WSAStartup(MAKEWORD(2,2), &wsaData);

    23.      ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    24.      u_short port = 27015;
    25.      char* ip;
    26.      sockaddr_in service;
    27.      service.sin_family = AF_INET;
    28.      service.sin_port = htons(port);
    29.      hostent* thisHost;
    30.      thisHost = gethostbyname("");
    31.      ip = inet_ntoa (*(struct in_addr *)*thisHost->h_addr_list);

    33.      service.sin_addr.s_addr = inet_addr(ip);

    35.      //-----------------------------------------
    36.      // Bind the listening socket to the local IP address
    37.      // and port number
    38.      bind(ListenSocket, (SOCKADDR *) &service, sizeof(SOCKADDR));

    40.      //-----------------------------------------
    41.      // Set the socket to listen for incoming
    42.      // connection requests
    43.      listen(ListenSocket, 1);
    44.      printf("Listening ");

    46.      //step2:
    47.      Accept=accept(Listen,NULL,NULL);

    49.      //step3:
    50.      //set up an overlapped structure
    51.      EventArray[EventTotal]=WSACreateEvent();//先存到事件数组中
    52.      ZeroMemory(&AcceptOverlapped,sizeof(WSAOVERLAPPED));
    53.      AcceptOverlapped.hEvent = EventArray[EventTotal];

    55.      DataBuf.len = DATA_BUFSIZE;
    56.      DataBuf.buf =buffer;

    58.      EventTotal++;

    60.      //step4:
    61.      //投递WSARecv准备在Accept套接字上接收数据
    62.      WSARecv(Accept,&DataBuf,1,&RecvBytes,&Flag,&AcceptOverlapped,NULL);

    64.      while (TRUE){
    65.          //step5:
    66.          //等待overlapped IO调用的完成
    67.          DWORD Index;
    68.          Index = WSAWaitForMultipleEvents(EventTotal, EventArray, FALSE, WSA_INFINITE, FALSE);

    70.          //step6:
    71.          // Reset the signaled event
    72.          WSAResetEvent(EventArray[Index - WSA_WAIT_EVENT_0]);

    74.          //step7:
    75.          // Determine the status of the overlapped event
    76.          WSAGetOverlappedResult(AcceptSocket, &AcceptOverlapped, &BytesTransferred, FALSE, &Flags);


    79.          // If the connection has been closed, close the accepted socket
    80.          if (BytesTransferred == 0) {
    81.              printf("Closing Socket %d ", AcceptSocket);
    82.              closesocket(AcceptSocket);
    83.              WSACloseEvent(EventArray[Index - WSA_WAIT_EVENT_0]);
    84.              return;
    85.          }

    87.          // If data has been received,do something with received data
    88.          //DataBuf contains the received data

    90.          //step8:
    91.          //post another WSARecv () request on the socket
    92.          Flag=0;
    93.          ZeroMemory(&AcceptOverlapped,sizeof(WSAOVERLAPPED));
    94.          AcceptOverlapped.hEvent=EventArray[Index - WSA_WAIT_EVENT_0];//该事件对象已经被复位

    96.          DataBuf.len = DATA_BUFSIZE;
    97.          DataBuf.buf =buffer;

    99.          WSARecv(Accept,&DataBuf,1,&RecvBytes,&Flag,&AcceptOverlapped,NULL);
    100.      }
    101.      return 0;
    102.  }

    改进后的程序（并非实际可以运行的程序，只是为了理清思路）：

    点击(此处)折叠或打开

    1. #define LISTEN_PORT 5000
    2.  #define DATA_BUFSIZE 8192
    3.  #define POST_RECV 0X01
    4.  #define POST_SEND 0X02

    6.  int main( )
    7.  {
    8.      LPPER_HANDLE_DATA lpPerHandleData;
    9.      SOCKET hListenSocket;
    10.      SOCKET hClientSocket;
    11.      SOCKADDR_IN ClientAddr;
    12.      int nAddrLen;
    13.      HANDLE hThread;

    15.      // Start WinSock and create a listen socket.

    17.      listen(hListenSocket, 5);
    18.      for (; ;)
    19.      {
    20.          nAddrLen = sizeof(SOCKADDR);
    21.          hClientSocket = accept(hListenSocket, (LPSOCKADDR)&ClientAddr, &nAddrLen);

    23.          lpPerHandleData = (LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));
    24.          lpPerHandleData->hSocket = hClientSocket;
    25.          // 注意这里将连接的客户端的IP地址，保存到了lpPerHandleData字段中了
    26.          strcpy(lpPerHandleData->szClientIP, inet_ntoa(ClientAddr.sin_addr));

    28.          // 为本次客户请求产生子线程
    29.          hThread = CreateThread(
    30.              NULL,
    31.              0,
    32.              OverlappedThread,
    33.              lpPerHandleData, // 将lpPerHandleData传给子线程
    34.              0,
    35.              NULL
    36.              );
    37.          CloseHandle(hThread);
    38.      }
    39.      return 0;
    40.  }

    42.  DWORD WINAPI OverlappedThread(LPVOID lpParam)
    43.  {
    44.      LPPER_HANDLE_DATA lpPerHandleData = (LPPER_HANDLE_DATA)lpParam;
    45.      WSAOVERLAPPED Overlapped;
    46.      WSABUF wsaBuf;
    47.      WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];//事件对象数组

    49.      DWORD dwEventTotal = 0, // 程序中事件的总数
    50.      char Buffer[DATA_BUFSIZE];
    51.      BOOL bResult;
    52.      int nResult;

    54.      EventArray[dwEventTotal] = WSACreateEvent();

    56.      ZeroMemory(&Overlapped, sizeof(WSAOVERLAPPED));

    58.      Overlapped.hEvent = EventArray[dwEventTotal]; // 关联事件

    60.      ZeroMemory(Buffer, DATA_BUFSIZE);
    61.      wsaBuf.buf = Buffer;
    62.      wsaBuf.len = sizeof(Buffer);
    63.      
    64.      lpPerHandleData->nOperateType = POST_RECV; // 记录本次操作是Recv(..)

    66.      dwEventTotal ++; // 总数加一
    67.      dwFlags = 0;

    69.      nResult = WSARecv(
    70.          lpPerHandleData->hSocket, // Receive socket
    71.          &wsaBuf, // 指向WSABUF结构的指针
    72.          1, // WSABUF数组的个数
    73.          &dwNumOfBytesRecved, // 存放当WSARecv完成后所接收到的字节数,实际接收到的字节数
    74.          &dwFlags, // A pointer to flags
    75.          &Overlapped, // A pointer to a WSAOVERLAPPED structure
    76.          NULL // A pointer to the completion routine,this is NULL
    77.          );

    79.      if ( nResult == SOCKET_ERROR && GetLastError() != WSA_IO_PENDING)
    80.      {
    81.          printf("WSARecv(..) failed. ");
    82.          free(lpPerHandleData);

    84.          closesocket(lpPerHandleData->hSocket;
    85.           WSACloseEvent(EventArray[dwEventTotal]);
    86.          return -1;
    87.      }

    89.      while (TRUE)
    90.      {
    91.          DWORD dwIndex;

    93.          dwIndex = WSAWaitForMultipleEvents(dwEventTotal, EventArray ,
    94.              FALSE ,WSA_INFINITE,FALSE);

    96.         WSAResetEvent(EventArray[dwIndex– WSA_WAIT_EVENT_0]);


    99.          bResult = WSAGetOverlappedResult(
    100.              lpPerHandleData->hSocket,
    101.              &Overlapped,
    102.              &dwBytesTransferred, // 当一个同步I/O完成后,接收到的字节数
    103.              TRUE, // 等待I/O操作的完成
    104.              &dwFlags
    105.              );
    106.          if (bResult == FALSE && WSAGetLastError() != WSA_IO_INCOMPLETE)
    107.          {
    108.              printf("WSAGetOverlappdResult(..) failed. ");
    109.              free(lpPerHandleData);
    110.              return 0; // 错误退出
    111.          }

    113.          if (dwBytesTransferred == 0)
    114.          {
    115.              printf("客户端已退出,将断开与之的连接! ");
    116.              closesocket(lpPerHandleData->hSocket);
    117.              free(lpPerHandleData);
    118.              break;
    119.          }

    121.          // 在这里将接收到的数据进行处理
    122.          printf("Received from IP: %s. data: %s ", lpPerHandleData->szClientIP, wsaBuf.buf);

    124.          // 发送另外一个请求操作
    125.          ZeroMemory(&Overlapped, sizeof(WSAOVERLAPPED));
    126.          lpPerHandleData->nOperateType = POST_RECV;

    128.          dwFlags = 0;
    129.          nResult = WSARecv();
    130.          if (){}

    132.      }

    134.      return 1;
    135.  }

    最后的一个改进版本，看上去是个不错的版本，相对来说算是比较实用的。但是使用了过多的全局变量，代码是C风格的，不可取。

    点击(此处)折叠或打开

    1. #include <winsock2.h>
    2.  #include <stdio.h>

    4.  #define PORT 5150
    5.  #define MSGSIZE 1024

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

    9.  typedef struct
    10.  {
    11.  WSAOVERLAPPED overlap;
    12.  WSABUF Buffer;
    13.  char szMessage[MSGSIZE];
    14.  DWORD NumberOfBytesRecvd;
    15.  DWORD Flags;
    16.  }PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

    18.  int g_iTotalConn = 0;
    19.  SOCKET g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
    20.  WSAEVENT g_CliEventArr[MAXIMUM_WAIT_OBJECTS];
    21.  LPPER_IO_OPERATION_DATA g_pPerIODataArr[MAXIMUM_WAIT_OBJECTS];

    23.  DWORD WINAPI WorkerThread(LPVOID);

    25.  void Cleanup(int);

    27.  int main()
    28.  {
    29.  WSADATA wsaData;
    30.  SOCKET sListen, sClient;
    31.  SOCKADDR_IN local, client;
    32.  DWORD dwThreadId;
    33.  int iaddrSize = sizeof(SOCKADDR_IN);
    34.  // Initialize Windows Socket library
    35.  WSAStartup(0x0202, &wsaData);
    36.  // Create listening socket
    37.  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    38.  // Bind
    39.  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    40.  local.sin_family = AF_INET;
    41.  local.sin_port = htons(PORT);
    42.  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));
    43.  // Listen
    44.  listen(sListen, 3);


    47. //网上的代码如此，好奇怪，为什么是在连接还没开始的时候就创建一个线程，而不是像上面的程序一样，accept一个
    48. //connection创建一个线程，并将从connection 的socket中获取的信息当作形参传递给workThread?
    49. //这里是只创建一个线程为重叠socket I/O操作服务
    50.  // Create worker thread
    51.  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
    52.  while (TRUE)
    53.  {
    54.      // Accept a connection
    55.      sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);

    57.          //这很好，在accept函数中的后两个形参中获取client的相关信息，并直接在server端的控制台中显示出来
    58.      printf("Accepted client:%s:%d ", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    59.      g_CliSocketArr[g_iTotalConn] = sClient;//添加到socket数组中
    60.     
    61.      // Allocate a PER_IO_OPERATION_DATA structure
    62.      g_pPerIODataArr[g_iTotalConn] = ER(LPPER_IO_OPATION_DATA)HeapAlloc(
    63.               GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(PER_IO_OPERATION_DATA));
    64.      g_pPerIODataArr[g_iTotalConn]->Buffer.len = MSGSIZE;
    65.      g_pPerIODataArr[g_iTotalConn]->Buffer.buf = g_pPerIODataArr[g_iTotalConn]->eszMssage;
    66.      g_CliEventArr[g_iTotalConn] = g_pPerIODataArr[g_iTotalConn]->overlap.hEvent = WSACreateEvent();
    67.      // Launch an asynchronous operation
    68.      WSARecv(
    69.        g_CliSocketArr[g_iTotalConn],
    70.        &g_pPerIODataArr[g_iTotalConn]->Buffer,
    71.        1,
    72.        &g_pPerIODataArr[g_iTotalConn]->NumberOfBytesRecvd,
    73.        &g_pPerIODataArr[g_iTotalConn]->Flags,
    74.        &g_pPerIODataArr[g_iTotalConn]->overlap,
    75.        NULL);
    76.     
    77.      g_iTotalConn++;
    78.  }

    80.  closesocket(sListen);
    81.  WSACleanup();
    82.  return 0;
    83.  }
    84.  DWORD WINAPI WorkerThread(LPVOID lpParam)
    85.  {
    86.  int ret, index;
    87.  DWORD cbTransferred;
    88.  while (TRUE)
    89.  {
    90.      ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);
    91.      if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
    92.      {
    93.        continue;
    94.      }
    95.      index = ret - WSA_WAIT_EVENT_0;
    96.      WSAResetEvent(g_CliEventArr[index]);
    97.      WSAGetOverlappedResult(
    98.        g_CliSocketArr[index],
    99.        &g_pPerIODataArr[index]->overlap,
    100.        &cbTransferred,
    101.        TRUE,
    102.        &g_pPerIODataArr[g_iTotalConn]->Flags);
    103.      if (cbTransferred == 0)
    104.      {
    105.        // The connection was closed by client
    106.        Cleanup(index);
    107.      }
    108.      else
    109.      {
    110.        // g_pPerIODataArr[index]->szMessage contains the received data
    111.        g_pPerIODataArr[index]->szMessage[cbTransferred] = '0';
    112.        send(g_CliSocketArr[index], g_pPerIODataArr[index]->szMessage,
    113.          cbTransferred, 0);
    114.        // Launch another asynchronous operation
    115.        WSARecv(
    116.          g_CliSocketArr[index],
    117.          &g_pPerIODataArr[index]->Buffer,
    118.          1,
    119.          &g_pPerIODataArr[index]->NumberOfBytesRecvd,
    120.          &g_pPerIODataArr[index]->Flags,
    121.          &g_pPerIODataArr[index]->overlap,
    122.          NULL);
    123.      }
    124.  }
    125.  return 0;
    126.  }
    127.  void Cleanup(int index)
    128.  {
    129.  closesocket(g_CliSocketArr[index]);
    130.  WSACloseEvent(g_CliEventArr[index]);
    131.  HeapFree(GetProcessHeap(), 0, g_pPerIODataArr[index]);
    132.  if (index < g_iTotalConn - 1)
    133.  {
    134.      g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn - 1];
    135.      g_CliEventArr[index] = g_CliEventArr[g_iTotalConn - 1];
    136.      g_pPerIODataArr[index] = g_pPerIODataArr[g_iTotalConn - 1];
    137.  }
    138.  g_pPerIODataArr[--g_iTotalConn] = NULL;
    139.  }

        这个模型与上述其他模型不同的是它使用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异步操作。

     

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

    上一篇：Linux C++中需要的头文件

    下一篇：【转】Linux AIO机制

    相关热门文章
    给主人留下些什么吧！~~
    评论热议
  • 相关阅读:
    AFHTTPRequestOperationManager的那些事
    iOS缩放图片
    iOS截图
    网络服务
    Six
    正文处理命令及tar命令
    用户，群组和权限 四
    用户，群组和权限 三
    用户，群组和权限 二
    用户，群组和权限 一
  • 原文地址：https://www.cnblogs.com/black/p/5171806.html
Copyright © 2011-2022 走看看