WIN网络编程-重叠I/0服务器设计

最新推荐文章于 2024-09-14 22:35:53 发布
最新推荐文章于 2024-09-14 22:35:53 发布
阅读量384 收藏
点赞数
分类专栏： C/C++ 文章标签： 服务器 编程 网络 socket buffer events

///
// OverlappedServer.cpp文件

//基于重叠I/0模型的简单的回显TCP服务器，它接受客户端连接之后，将从客

//户端接收到的数据再发送给客户端。本例采用了单线程。

//使用重叠I/O模型必须使用WSASocket函数创建套接字,传送数据使用

//WSASend、WSARecv、WSARecvFrom

//WSASocket函数创建套接字，这个套接字允许多个I/O同时占用。并使用pBuff

//er->pSocket->nOutstandingOps来统计其上的I/O数量。

//其中SOCKET_OBJ结构用来记录与套接字相关的信息，BUFFER_OBJ记录I/O信息。

//程序每投递一个I/O请求，都要申请一个BUFFER_OBJ对象，使用嵌在对象中

//的OVERLAPPED结构。所有未完成的I/O请求对应的BUFFER_OBJ对象组成了一个

//表，表头指针为全局变量g_pBufferHead。

//提交重叠I/O是重叠模型的关键，通过调用AcceptEx、WSARecv和WSASend函

//数实现。提交这些I/O后，线程便在重叠结构中的事件对象上等等，一旦I/O完成

//事件受信，等待函数返回。

//WSAGetLastError函数报告了WSA_IO_PENDING出错状态，表示I/O操作正在进行。

//AccepEx函数将几个套接字函数的功能集合成在了一起。如果它投递的请求成功完成，则执行了3个操作：

//1、接受了新的连接

//2、新连接的本地地址和远程地址都会返回

//3、接收到了远程主机发来的第一块数据

//

 

 

#include "../common/initsock.h"

#include<Mswsock.h>
#include <stdio.h>
#include <windows.h>

CInitSock theSock;

#define BUFFER_SIZE 1024

typedef struct _SOCKET_OBJ
{
 SOCKETs;      //套节字句柄
 intnOutstandingOps;   //记录此套节字上的重叠I/O数量
 
 LPFN_ACCEPTEXlpfnAcceptEx;  //扩展函数AcceptEx的指针（仅对监听套节字而言）
} SOCKET_OBJ, *PSOCKET_OBJ;

//重叠I/O都要提交到特定套节字上。在这些I/O完成之前，对方关闭了连接，

//或者连接发生错误，释放对应的SOCEKET_OBJ对象。

typedef struct _BUFFER_OBJ
{ 
 OVERLAPPEDol;   //重叠结构
 char*buff;    //send/recv/AcceptEx所使用的缓冲区
 intnLen;    //buff的长度
 PSOCKET_OBJ pSocket; //此I/O所属的套节字对象

 intnOperation;   //提交的操作类型
#define OP_ACCEPT 1
#define OP_READ  2
#define OP_WRITE 3

 SOCKETsAccept;   //用来保存AcceptEx接受的客户套节字（仅对监听套节字而言）
 _BUFFER_OBJ *pNext;
} BUFFER_OBJ, *PBUFFER_OBJ;

HANDLEg_events[WSA_MAXIMUM_WAIT_EVENTS]; //I/O事件句柄数组
intg_nBufferCount;       //上数组中有效句柄数量
PBUFFER_OBJ g_pBufferHead, g_pBufferTail; //记录缓冲区对象组成的表的地址

// 申请套节字对象和释放套节字对象的函数
PSOCKET_OBJ GetSocketObj(SOCKET s)
{
 PSOCKET_OBJ pSocket =(PSOCKET_OBJ)::GlobalAlloc(GPTR, sizeof(SOCKET_OBJ));
 if(pSocket != NULL)
 {
  pSocket->s =s;
 }
 return pSocket;
}
void FreeSocketObj(PSOCKET_OBJ pSocket)
{
 if(pSocket->s !=INVALID_SOCKET)
  ::closesocket(pSocket->s);
 ::GlobalFree(pSocket);
}

PBUFFER_OBJ GetBufferObj(PSOCKET_OBJ pSocket,ULONG nLen)
{
 if(g_nBufferCount >WSA_MAXIMUM_WAIT_EVENTS - 1)
  return NULL;

 PBUFFER_OBJ pBuffer =(PBUFFER_OBJ)::GlobalAlloc(GPTR, sizeof(BUFFER_OBJ));
 if(pBuffer != NULL)
 {
  pBuffer->buff =(char*)::GlobalAlloc(GPTR, nLen);
  pBuffer->ol.hEvent= ::WSACreateEvent();
  pBuffer->pSocket= pSocket;
  pBuffer->sAccept= INVALID_SOCKET;

  //将新的BUFFER_OBJ添加到列表中
  if(g_pBufferHead == NULL)
  {
   g_pBufferHead= g_pBufferTail = pBuffer;
  }
  else
  {
   g_pBufferTail->pNext= pBuffer;
   g_pBufferTail= pBuffer;
  }
  g_events[++ g_nBufferCount] =pBuffer->ol.hEvent;
 }
 return pBuffer;
}

void FreeBufferObj(PBUFFER_OBJ pBuffer)
{
 // 从列表中移除BUFFER_OBJ对象
 PBUFFER_OBJ pTest = g_pBufferHead;
 BOOL bFind = FALSE;
 if(pTest == pBuffer)
 {
  g_pBufferHead = g_pBufferTail =NULL;
  bFind = TRUE;
 }
 else
 {
  while(pTest != NULL&& pTest->pNext !=pBuffer)
   pTest =pTest->pNext;
  if(pTest != NULL)
  {
   pTest->pNext= pBuffer->pNext;
   if(pTest->pNext== NULL)
    g_pBufferTail= pTest;
   bFind =TRUE;
  }
 }
 // 释放它占用的内存空间
 if(bFind)
 {
  g_nBufferCount --;
  ::CloseHandle(pBuffer->ol.hEvent);
  ::GlobalFree(pBuffer->buff);
  ::GlobalFree(pBuffer); 
 }
}

PBUFFER_OBJ FindBufferObj(HANDLE hEvent)
{
 PBUFFER_OBJ pBuffer = g_pBufferHead;
 while(pBuffer != NULL)
 {
  if(pBuffer->ol.hEvent== hEvent)
   break;
  pBuffer =pBuffer->pNext;
 }
 return pBuffer;
}

void RebuildArray()
{
 PBUFFER_OBJ pBuffer = g_pBufferHead;
 int i =  1;
 while(pBuffer != NULL)
 {
  g_events[i++] =pBuffer->ol.hEvent;
  pBuffer =pBuffer->pNext;
 }
}

BOOL PostAccept(PBUFFER_OBJ pBuffer)
{
 PSOCKET_OBJ pSocket =pBuffer->pSocket;
 if(pSocket->lpfnAcceptEx !=NULL)
 { 
  // 设置I/O类型，增加套节字上的重叠I/O计数
  pBuffer->nOperation= OP_ACCEPT;
  pSocket->nOutstandingOps++;

  //投递此重叠I/O 
  DWORD dwBytes;
  pBuffer->sAccept=
   ::WSASocket(AF_INET,SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
  BOOL b =pSocket->lpfnAcceptEx(pSocket->s,
   pBuffer->sAccept,
   pBuffer->buff,
   BUFFER_SIZE -((sizeof(sockaddr_in) + 16) * 2),
   sizeof(sockaddr_in)+ 16,
   sizeof(sockaddr_in)+ 16,
   &dwBytes,
   &pBuffer->ol);
  if(!b)
  {
   if(::WSAGetLastError()!= WSA_IO_PENDING)
    returnFALSE;
  }
  return TRUE;
 }
 return FALSE;
};

BOOL PostRecv(PBUFFER_OBJ pBuffer)
{ 
 // 设置I/O类型，增加套节字上的重叠I/O计数
 pBuffer->nOperation =OP_READ;
 pBuffer->pSocket->nOutstandingOps++;

 // 投递此重叠I/O
 DWORD dwBytes;
 DWORD dwFlags = 0;
 WSABUF buf;
 buf.buf = pBuffer->buff;
 buf.len = pBuffer->nLen;
 if(::WSARecv(pBuffer->pSocket->s,&buf, 1, &dwBytes,&dwFlags,&pBuffer->ol, NULL) !=NO_ERROR)
 {
  if(::WSAGetLastError() !=WSA_IO_PENDING)
   returnFALSE;
 }
 return TRUE;
}

BOOL PostSend(PBUFFER_OBJ pBuffer)
{
 // 设置I/O类型，增加套节字上的重叠I/O计数
 pBuffer->nOperation =OP_WRITE;
 pBuffer->pSocket->nOutstandingOps++;

 // 投递此重叠I/O
 DWORD dwBytes;
 DWORD dwFlags = 0;
 WSABUF buf;
 buf.buf = pBuffer->buff;
 buf.len = pBuffer->nLen;
 if(::WSASend(pBuffer->pSocket->s,
   &buf,1, &dwBytes, dwFlags,&pBuffer->ol, NULL) !=NO_ERROR)
 {
  if(::WSAGetLastError() !=WSA_IO_PENDING)
   returnFALSE;
 }
 return TRUE;
}

BOOL HandleIO(PBUFFER_OBJ pBuffer)
{
 PSOCKET_OBJ pSocket =pBuffer->pSocket; //从BUFFER_OBJ对象中提取SOCKET_OBJ对象指针，为的是方便引用
 pSocket->nOutstandingOps--;

 // 获取重叠操作结果
 DWORD dwTrans;
 DWORD dwFlags;
 BOOL bRet =::WSAGetOverlappedResult(pSocket->s,&pBuffer->ol,&dwTrans, FALSE, &dwFlags);
 if(!bRet)
 {
  //在此套节字上有错误发生，因此，关闭套节字，移除此缓冲区对象。
  //如果没有其它抛出的I/O请求了，释放此缓冲区对象，否则，等待此套节字上的其它I/O也完成
  if(pSocket->s !=INVALID_SOCKET)
  {
   ::closesocket(pSocket->s);
   pSocket->s= INVALID_SOCKET;
  }

  if(pSocket->nOutstandingOps== 0)
   FreeSocketObj(pSocket); 
  
  FreeBufferObj(pBuffer);
  return FALSE;
 }

 // 没有错误发生，处理已完成的I/O
 switch(pBuffer->nOperation)
 {
 case OP_ACCEPT: //接收到一个新的连接，并接收到了对方发来的第一个封包
  {
   //为新客户创建一个SOCKET_OBJ对象
   PSOCKET_OBJpClient = GetSocketObj(pBuffer->sAccept);

   //为发送数据创建一个BUFFER_OBJ对象，这个对象会在套节字出错或者关闭时释放
   PBUFFER_OBJpSend = GetBufferObj(pClient, BUFFER_SIZE); 
   if(pSend ==NULL)
   {
    printf("Too much connections! /n");
    FreeSocketObj(pClient);
    returnFALSE;
   }
   RebuildArray();
   
   //将数据复制到发送缓冲区
   pSend->nLen= dwTrans;
   memcpy(pSend->buff,pBuffer->buff, dwTrans);

   //投递此发送I/O（将数据回显给客户）
   if(!PostSend(pSend))
   {
    //万一出错的话，释放上面刚申请的两个对象
    FreeSocketObj(pSocket); 
    FreeBufferObj(pSend);
    returnFALSE;
   }
   //继续投递接受I/O
   PostAccept(pBuffer);
  }
  break;
 case OP_READ: // 接收数据完成
  {
   if(dwTrans> 0)
   {
    //创建一个缓冲区，以发送数据。这里就使用原来的缓冲区
    PBUFFER_OBJpSend = pBuffer;
    pSend->nLen= dwTrans;
    
    //投递发送I/O（将数据回显给客户）
    PostSend(pSend);
   }
   else //套节字关闭
   {
 
    //必须先关闭套节字，以便在此套节字上投递的其它I/O也返回
    if(pSocket->s!= INVALID_SOCKET)
    {
     ::closesocket(pSocket->s);
     pSocket->s= INVALID_SOCKET;
    }

    if(pSocket->nOutstandingOps== 0)
     FreeSocketObj(pSocket);  
    
    FreeBufferObj(pBuffer);
    returnFALSE;
   }
  }
  break;
 caseOP_WRITE:  // 发送数据完成
  {
   if(dwTrans> 0)
   {
    //继续使用这个缓冲区投递接收数据的请求
    pBuffer->nLen= BUFFER_SIZE;
    PostRecv(pBuffer);
   }
   else //套节字关闭
   {
    //同样，要先关闭套节字
    if(pSocket->s!= INVALID_SOCKET)
    {
     ::closesocket(pSocket->s);
     pSocket->s= INVALID_SOCKET;
    }

    if(pSocket->nOutstandingOps== 0)
     FreeSocketObj(pSocket); 

    FreeBufferObj(pBuffer);
    returnFALSE;
   }
  }
  break;
 }
 return TRUE;
}


void main()
{
 // 创建监听套节字，绑定到本地端口，进入监听模式
 int nPort = 4567;
 SOCKET sListen =
  ::WSASocket(AF_INET,SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);

//plisten可被多个重叠I/O占用
 SOCKADDR_INsi;
 si.sin_family = AF_INET;
 si.sin_port = ::ntohs(nPort);
 si.sin_addr.S_un.S_addr = INADDR_ANY;
 ::bind(sListen, (sockaddr*)&si,sizeof(si));
 ::listen(sListen, 200);

 // 为监听套节字创建一个SOCKET_OBJ对象
 PSOCKET_OBJ pListen = GetSocketObj(sListen);

 // 加载扩展函数AcceptEx
 GUID GuidAcceptEx = WSAID_ACCEPTEX;
 DWORD dwBytes;
 WSAIoctl(pListen->s,
  SIO_GET_EXTENSION_FUNCTION_POINTER,
  &GuidAcceptEx,
  sizeof(GuidAcceptEx),
  &pListen->lpfnAcceptEx,
  sizeof(pListen->lpfnAcceptEx),
  &dwBytes,
  NULL,
  NULL);

 // 创建用来重新建立g_events数组的事件对象
 g_events[0] = ::WSACreateEvent();

 // 在此可以投递多个接受I/O请求
 for(int i=0; i<5; i++)
 {
  PostAccept(GetBufferObj(pListen,BUFFER_SIZE));
 }
 ::WSASetEvent(g_events[0]);
 
 while(TRUE)
 {
  int nIndex =
   ::WSAWaitForMultipleEvents(g_nBufferCount+ 1, g_events, FALSE, WSA_INFINITE, FALSE);
  if(nIndex ==WSA_WAIT_FAILED)
  {
   printf("WSAWaitForMultipleEvents()failed /n");
   break;
  }
  nIndex = nIndex -WSA_WAIT_EVENT_0;
  for(int i=0;i<=nIndex; i++)
  {
   int nRet =::WSAWaitForMultipleEvents(1, &g_events[i], TRUE,0, FALSE);
   if(nRet ==WSA_WAIT_TIMEOUT)
    continue;
   else
   {
    ::WSAResetEvent(g_events[i]);
    //重新建立g_events数组
    if(i== 0)
    {
     RebuildArray();
     continue;
    }

    //处理这个I/O
    PBUFFER_OBJpBuffer = FindBufferObj(g_events[i]);
    if(pBuffer!= NULL)
    {
     if(!HandleIO(pBuffer))
      RebuildArray();
    }
   }
  }
 }
}

 

deepfuture
关注
专栏目录
采用重叠I/O技术的Socket客户端代码
castmoon的专栏
03-12 1022
  #ifdef _DEBUG#define GMT_ASSERT(exp)  assert(exp)#else#define GMT_ASSERT(exp)#endif#define PORT 5150#define DATA_BUFSIZE 8192// Overlapped event.#define RECV_WSAEVENT 0#define SEND_WSA
Windows下重叠I/O模型
踏雪无痕
10-16 4125
 一.Windows下重叠I/O模型1． 重叠模型的优点2． 重叠模型的基本原理3． 关于重叠模型的基础知识4． 重叠模型的实现步骤5． 多客户端情况的注意事项 二．重叠模型的优点 1.可以运行在支持Winsock2的所有Windows平台 ,而不像完成端口只是支持NT系统。2.比起阻塞、select、WSAAsyncSelect以及WSAEventSelect等模型，重叠I/
手把手教你玩转SOCKET模型之重叠I/O篇（下）
热门推荐
小猪的网络编程
09-23 15万+
四。     实现重叠模型的步骤作了这么多的准备工作，费了这么多的笔墨，我们终于可以开始着手编码了。其实慢慢的你就会明白，要想透析重叠结构的内部原理也许是要费点功夫，但是只是学会如何来使用它，却是真的不难，唯一需要理清思路的地方就是和大量的客户端交互的情况下，我们得到事件通知以后，如何得知是哪一个重叠操作完成了，继而知道究竟该对哪一个套接字进行处理，应该去哪个缓冲区中的取得数据，everyth
基于重叠IO模型的 回显TCP服务器设计
weixin_34403693的博客
10-14 120
---------------------1 套接字对象---------------------- 为每个套接字创建一个SOCKET_OBJ对象，记录与之相关的信息。 typedef struct _SOCKET_OBJ{ SOCKET s; int nOutstandingOps;//重叠IO数量 LPFN_ACCEPTEX lpfnAcceptEx; ...
基于重叠I/O模型的服务器实践(以事件驱动)
Datura_Metel的博客
04-18 400
服务器端#include "winsock2.h"#pragma comment(lib, "ws2_32.lib")#include &lt;iostream&gt;using namespace std;#define MAXDATASIZE 200int main(){    WSABUF DataBuf;    char buffer[MAXDATASIZE];    DWORD Even...
Windows网络编程-I/O模式
zhenpeanut的博客
03-03 425
首先说明什么是Windows套接字模式. 其分为两类:阻塞模式/非阻塞模式. 阻塞模式:I/O操作完成前执行操作的WinSock调用会一直等候下去,不会立即返回到程序中. 非阻塞模式:WinSock函数无论如何都会立即返回. 对阻塞套接字 他的一个缺点在于,应用程序很难同时通过多个建好连接的套接字通信,使用前述的方案,可对应用程序进行修改,令其为连接好的每个套接字都分配一个读线程,以及一个数据处理...
windows网络编程------，重叠io，完成端口
qq_40140790的博客
05-05 1283
在了解完成端口之前，我们先要了解重叠io（完成端口是基于重叠io上实现的） 重叠io，即执行I/O请求的时间与线程执行其他任务的时间是重叠(overlapped)的。我们正常的的socket是socket到达后，系统通知我们socket到了，然后我们用recv把socket缓存里面的信息复制到内存上来，这个io的步骤就花了可观的时间，但cpu的占用却很少，就不能想个办法在我们读写的时候还能做其他...
网络编程实用教程(第三版).zip
06-10
1.1　网络编程相关的基本概念　1 1.1.1　网络编程与进程通信　1 1.1.2　Internet中网间进程的标识　3 1.1.3　网络协议的特征　7 1.2　三类网络编程　10 1.2.1　基于TCP/IP协议栈的网络编程　10 1.2.2　基于WWW应用的...
Windows Socket编程：五种I/O模型详解
"Windows操作系统为开发网络应用程序的程序员提供了五种不同的I/O模型，包括选择(Select)、异步选择(WSAAsyncSelect)、事件选择(WSAEventSelect)、重叠I/O(Overlapped I/O)以及完成端口(Completion Port)。...
Linux网络-传输层UDP/TCP详解
TPON的博客
04-20 1449
目录：计算机网络的层状结构，UDP协议，UDP报文格式，理解UDP/TCP报文的本质，UDP的特点，UDP的缓冲区，sendto/recvfrom/send/recv/write/read IO类接口，UDP是全双工的，UDP注意事项，UDP协议，实现简单聊天室（服务端+客户端） TCP协议，TCP协议段格式，确认应答（ACK）机制，TCP全双工，具有发送缓冲区和接收缓冲区，流量控制，连接管理机制，如何理解连接，理解 - TCP建立连接的三次握手 理解-TCP断开连接四次挥手，TCP四次挥手的状态变化。
WinSock重叠I/O模型
netanimals的专栏
05-26 740
<br />一．重叠I/O的概念及应用<br />当调用ReadFile和WriteFile时，如果最后一个参数lpOverlapped设置为NULL，那么线程就阻塞在这里，直到读写完指定的数据后，它们才返回。这样在读写大文件的时候，很多时间都浪费在等待ReadFile和WriteFile的返回上面。如果ReadFile和WriteFile是往管道里读写数据，那么有可能阻塞得更久，导致程序性能下降。<br />为了解决这个问题，windows引进了重叠I/O的概念，它能够同时以多个线程处理多个I/O。其实你
SOCKET编程——重叠IO网络模型（服务器端）
liuguangshibei的博客
08-22 530
#include<WinSock2.h> #include<stdio.h> #include<iostream> #include<string> #include<stdlib.h> #include<mswsock.h>//一定要放在include<WinSock2.h>的下面 #pragma comment(lib, "Mswsock.lib") #pragma comment(lib,"ws2_32.lib") u
Socket模型之重叠I/O模型
MengDeMao1234的博客
11-14 223
Socket模型之重叠I/O模型 这几天一直在看关于Socket编程的几种异步编程，我觉得关于重叠I/O模型的一些基本知识，我有必要记下来。 首先，我觉得重叠模型的有点就是允许应用程序使用重叠数据结构一次投递一个或多个异步I/O请求，当提交的请求完成之后，与之关联的重叠数据结构中关联的事件对象就会受信，然后应用程序就可以通过WSAWaitForMultipleEvents函数来判...
socket网络编程服务端程序支持多客户端（重叠I/O方式）
hill_guo的博客
05-07 3328
1.采用重叠I/O方式实现的socket网络编程，异步非阻塞方式，代码效率比阻塞式的socket编程方式高。2.实现了TCP server方式，只用于服务端，可以支持多客户端。3.可以使用在各种场合用于监控网络数据。4.代码封装成库形式，非常方便移植。5.本程序使用到了多线程技术，互斥同步线程技术，同时支持多通道连接技术，非常经典，程序注释完整，思路清晰。6.平台使用的是VC6.0，语言用的是...
windows socket网络编程五：重叠IO模型
c++小白的博客
01-05 1681
文章目录分析事件通知重叠IO结构体创建支持重叠IO的socket投递异步Accept投递异步Recv投递异步Send询问事件获取重叠信号分类处理运行结果完成例程投递异步Accept投递异步Recv投递异步Send分类处理运行结果模型流程图源码链接 分析 在解决了select模型本身的同步阻塞问题后，我们还要处理send、recv、accept的执行阻塞。 我们socket的操作本质上都是字符串的拷贝复制，重叠IO是windows提供的一种异步读写文件的机制，将读的指令以及我们的buffer投给操作系统，然后
关于高性能服务器底层网络通信模块的设计方法
Linuxhus的博客
09-17 486
高性能服务器底层网络通信模块的设计方法 在对I/O完成端口进行底层封装的基础上，本文提出一种具有高性能的、可扩展性的通用网络通信模块设计方案。该方案采用多种系统性能优化技术，如线程池、对象池和环形缓存区等。该模块在Win32平台上用c++开发完成，经过严格的压力和性能测试后，实验结果表明该模块能够支持海量并发连接，具有较高的数据吞吐量，在实际项目应用中也取得了良好的表现。 1、概述 　　要设计与开发出一款高性能的服务器(如网游服务器、Web服务器和代理服务器等)，一般都采用高效率的网络...
ASIO网络调试助手之三：ASIO网络编程注意事项
最新发布
草上爬的博客
09-14 1257
之前用过uv-cpp，和ASIO一样， 也支持异步机制，因此ASIO用起来还是比较顺手的，下面是个人总结的四点注意事项。
SOCKET重叠I/O模型
weixin_33724570的博客
01-06 145
1重叠模型的优点1可以运行在支持Winsock2的所有Windows平台,而不像完成端口只支持NT系统2比起阻塞,select,WSAAsyncSelect以及WSAEventSelect等模型,重叠I/O(Overlapped I/O)模型使应用程序能达到更加系统性能因为他和其他4种模型不同的是,使用重叠模型的应用程序通知缓冲区收发系统直接使用数据,也就是说,如果应用程序投...
网络编程——重叠I/O模型
beilizhang的博客
05-05 3043
参考 《TCP/IP网络编程》 尹圣雨 重叠I/O模型 理解重叠I/O模型 同一线程内部向多个目标传输（或从多个目标接收）数据引起的I/O重叠现象称为“重叠I/O”。为了完成这项任务，调用的I/O函数应立即返回，因此前提条件是异步I/O。而且，为了完成异步I/O，调用的I/O函数应以非阻塞模式工作 Windows中重叠I/O的重点并非I/O本身，而是如何确认I/O完成时的状态 创建重叠I/O套接字 #include <winsock2.h> SOCKET WSASocket(int af,
TCP/IP网络编程_基于Windows的编程_第22章重叠I/O模型
weifc-wei 的博客
06-18 304
22.1 理解重叠 I/O 模型 第21章异步处理的并非I/O, 而是"通知". 本章讲解的才是以异步方式处理 I/O 的方法. 只有理解了二者的区别和各自的优势, 才能更轻松地学习第23章的 IOCP. 重叠 I/O 其实各位对于重叠 I/O 并不陌生. 大家已经掌握了异步 I/O. 我通过图21-2说明过异步I/O模型, 实际上, 这种异步 I/O 就相当于 重叠I/O. 下面我将给出重叠I/O, 各位可自行判断二者是否相似. 图22-1 给出重叠 I/O 的原理. 如图22-1 所示, 同一线程内.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值