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机制

    相关热门文章
    给主人留下些什么吧！~~
    评论热议
  • 相关阅读:
    web前端的发展态势
    AngularJs 简单入门
    css代码优化篇
    git提交报错：Please make sure you have the correct access rights and the repository exists.
    Activiti工作流框架学习
    遍历map集合的4种方法
    js设置日期、月份增加减少
    Invalid character found in the request target. The valid characters are defined in RFC 7230 and RFC 3986
    webservice_rest接口_学习笔记
    相互匹配两个list集合+动态匹配${}参数
  • 原文地址：https://www.cnblogs.com/black/p/5171806.html
Copyright © 2011-2022 走看看