重叠（overlapped）I/O模型

最新推荐文章于 2023-09-28 17:16:05 发布
最新推荐文章于 2023-09-28 17:16:05 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： windows编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjxyshell/article/details/18016249
版权


 重叠I/O模型是异步IO模型。  先简单说明下 同步IO和异步IO操作，


同步IO模型： 当一个线程启动一个I/O操作时，进入等待状态，等到IO操作完成结束后，才继续执行。

异步IO模型，当一个线程启动一个I/O时，通常会将I/O处理和某一内核对象绑定，I/O函数会立即返回，不会等待，等到系统处理完此I/O操作时，通知绑定的内核对象，I/O处理结束了。


下面的代买是 windows 网络与通信程序设计 书中的，笔者简单的测试了下，简单了解下重叠Io模型的操作

initsock.h :

#include <WinSock2.h>
#include <mswsock.h>
#pragma comment(lib,"WS2_32")
class CInitSock
{
public:
	CInitSock(BYTE minorVer = 2,BYTE majorVer = 2)
	{
		//初始化ws2_32.dll
		WSADATA wsaData;
		WORD sockVersion = MAKEWORD(minorVer, majorVer);
		if(WSAStartup(sockVersion, &wsaData) != 0)
		{
			exit(0);
		}
	}
	~CInitSock()
	{
		WSACleanup();
	}
};

代码： 

#include "../initsock.h"
#include <stdio.h>
#include <Windows.h>
CInitSock initSock;
#define  PORT 4567
#define BUFFER_SIZE 1024

typedef struct _SOCKET_OBJ
{
	SOCKET s;   //套接字句柄;
	int nOutstandingOps;  //记录次套接字上重叠I/O的数量;
	LPFN_ACCEPTEX lpfnAcceptEx;  //扩展函数AcceptEx的指针(仅对监听套接字而言);
}SOCKET_OBJ,*PSOCKET_OBJ;

//缓冲区对象结构,记录重叠I/O的所有属性;
typedef struct _BUFFER_OBJ
{
	OVERLAPPED ol;  //重叠结构;
	char *buff;   //send,recv,acceptex所使用的缓冲区;
	int nLen; //buff 的长度;
	PSOCKET_OBJ pSocket; //此I/O所属的套接字对象;
	int nOperation;   //提交的操作类型;
#define OP_ACCEPT  1;
#define OP_READ    2;
#define OP_WRITE   3;
	SOCKET sAccept;   //用来保存AcceptEx接受客户端的套接字(仅对监听套接字而言);
	_BUFFER_OBJ *pNext;
}BUFFER_OBJ,*PBUFFER_OBJ;

HANDLE g_events[WSA_MAXIMUM_WAIT_EVENTS]; //I/O事件句柄数组;
int g_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->nOutstandingOps != 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);
	}
}
//在缓冲区中查找BUFFER_OBJ对象;
PBUFFER_OBJ FindBufferObj(HANDLE hEvent)
{
	PBUFFER_OBJ pBuffer = g_pBufferHead;
	while (pBuffer != NULL)
	{
		if(pBuffer->ol.hEvent == hEvent)
			break;
		pBuffer = pBuffer->pNext;
	}
	return pBuffer;
}
//更新句柄数组g_events中的内容;
void RebuildArrary()
{
	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)
	{
		//设置IO类型，增加套接字上的技术
		pBuffer->nOperation = OP_ACCEPT;
		pSocket->nOutstandingOps++;
		//投递此重叠IO
		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)
				return FALSE;
		}
		return TRUE;
	}
	return FALSE;
}
//接收数据
BOOL PostRecv(PBUFFER_OBJ pBuffer)
{
	//设置IO类型，增加套接字上重叠IO计数
	pBuffer->nOperation = OP_READ;
	pBuffer->pSocket->nOutstandingOps++;
	//投递此重叠IO
	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)
			return FALSE;
	}
	return TRUE;

}
//发送函数
BOOL PostSend(PBUFFER_OBJ pBuffer)
{
	pBuffer->nOperation = OP_WRITE;
	pBuffer->pSocket->nOutstandingOps++;
	//投递次IO
	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)
			return FALSE;
	}
	return TRUE;
}

//IO 请求处理函数
BOOL HandleIo(PBUFFER_OBJ pBuffer)
{
	PSOCKET_OBJ pSocket = pBuffer->pSocket;
	pSocket->nOutstandingOps--;
	//获取操作结果
	DWORD dwTrans;
	DWORD dwFlag;
	BOOL bRet = WSAGetOverlappedResult(pSocket->s,
									&pBuffer->ol,
									&dwTrans,
									FALSE,
									&dwFlag);
	if(!bRet)
	{
		if(pSocket->s == INVALID_SOCKET)
		{
			closesocket(pSocket->s);
			pSocket->s = INVALID_SOCKET;
		}
		if(pSocket->nOutstandingOps == 0)
		{
			FreeSocketObj(pSocket);
		}
		FreeBufferObj(pBuffer);
		return FALSE;
	}
	//没有错误发生
	//处理已完成的IO
	switch (pBuffer->nOperation)
	{
	case 1:    //接到一个新的连接,并受到对方发来的第一个封包op_accept
		{

			//为新客户端创建一个SOCKET_OBJ 对象
			PSOCKET_OBJ pClient = GetSocketObj(pBuffer->sAccept);
			//为发送的数据创建一个BUFFER_OBJ的对象，这个对象会在套接字出错或者关闭时释放
			PBUFFER_OBJ pSend = GetBufferObj(pClient,BUFFER_SIZE);
			if(pSend == NULL)
			{
				printf("too much connections\n");
				FreeSocketObj(pClient);
				return FALSE;
			}
			RebuildArrary();
			//将数据复制到发送缓冲区
			pSend->nLen = dwTrans;
			memcpy(pSend->buff,pBuffer->buff,dwTrans);
			//投递IO，将数据发送给客户端
			if (!PostSend(pSend))
			{
				//如果出错,释放上面的两个对象
				FreeBufferObj(pSend);
				FreeSocketObj(pClient);
				return FALSE;
			}
			printf("one connect coming!\n ");
			PostAccept(pBuffer);
			break;
		}
	case 2:    //接收数据完成 op_read
		{
			if(dwTrans>0)
			{
				//创建一个缓冲区，以发送数据，这里使用原来的缓冲区
				PBUFFER_OBJ pSend = pBuffer;  //将原来的和数据发回去
				pSend->nLen = dwTrans;
				//投递发送Io(将数据同步回显给客户端)
				PostSend(pSend);
			}
			else
			{
					//关闭套接字,以便次套接字上的投递的其他的IO也返回
				if(pSocket->s != INVALID_SOCKET)
				{
					closesocket(pSocket->s);
					pSocket->s = INVALID_SOCKET;
				}
				if(pSocket->nOutstandingOps == 0)
				{
					FreeSocketObj(pSocket);
				}
				FreeBufferObj(pBuffer);
				return FALSE;
			}
			break;
		}
	case 3:   //发送数据完成 op_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);
				return FALSE;
			}
			break;
		}
		
	}
	return TRUE;
}
//主函数
int main()
{
	SOCKET sListen = ::WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
	SOCKADDR_IN si;
	si.sin_family = AF_INET;
	si.sin_port = ::ntohs(PORT);
	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));
	}
	while(1)
	{
		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<=g_nBufferCount; 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)
				{
					RebuildArrary();
					continue;
				}
				//处理这个IO
				PBUFFER_OBJ pBuffer = FindBufferObj(g_events[i]);
				if(pBuffer != NULL)
				{
					if(!HandleIo(pBuffer))
						RebuildArrary();
				}
			}
		}
	}

	return 1;
}


PS：  对于程序中使用两层循环调用 WSAWaitForMultipleEvents()函数，不太明白，网上搜索了下资料，解释如下：

第一个WSAWaitForMultipleEvents是等待事件对象Signal，如果同时有多个事件对象受信，WSAWaitForMultipleEvents函数的返回值也只能指明其中的一个，就事件句柄数组中最前面的那个。如果这个指明的事件对象总有网络事件发生，那么后面的其他事件对象所关联的网络事件就得不到及时的处理。因此WSAWaitForMultipleEvents函数返回以后，对每个事件对象再次调用WSAWaitForMultipleEvents函数，以确定其状态。


多个内核对象被触发时，WaitForMultipleObjects选择其中序号最小的返回。而WaitForMultipleObjects它只会改变使它返回的那个内核对象的状态。
这儿又会产生一个问题，如果序号最小的那个对象频繁被触发，那么序号比它大的内核对象将得不到被处理的机会。
为了解决这一问题，可以采用双WaitForMultipleObjects检测机制来实现。



 

寒江雪语
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WinSock I/O 模型 -- OVERLAPPED I/O 模型
Useless Programmer 的专栏
11-14 463
简介 OVERLAPPED I/O 模型也是 WinSock 中常见的异步 I/O 模型，相比于我们之前提到的 Select 模型，WSAAsyncSelect 模型 和 WSAEventSelect 模型有更好的性能. 为了方便描述，下文我们将称 Overlapped I/O 模型为 “重叠模型”. 重叠模型的基本设计原理便是让应用程序使用一个 重叠的数据结构(Overlapped)，一次投递一个或多个 Winsock I/O 请求。针对那些提交的请求，在它们完成 之后，应用程序可为它们提供服务 使用这个
重叠（Overlapped）I/O模型
一直在路上
03-07 2051
与介绍过的其他模型相比，重叠I/O模型提供了更好的系统性能。这个模型的基本设计思想是允许应用程序使用重叠数据结构一次投递一个或者多个异步I/O请求（即所谓的重叠I/O）。提交的I/O请求完成之后，与之关联的重叠数据结构中的事件对象受信，应用程序便可使用WSAGetOverlappedResult函数获取重叠操作结果。这和使用重叠结构调用ReadFile和WriteFile函数操作文件类似。   
12.3 串行通信与重叠I/O
zmq5411的专栏
07-06 723
Win 32系统为串行通信提供了全新的服务。传统的OpenComm、ReadComm、WriteComm、CloseComm等函数已经过时，WM_COMMNOTIFY消息也消失了。取而代之的是文件I/O函数提供的打开和关闭通信资源句柄及读写操作的基本接口。新的
overlapped编程
05-03 128
int main(void) { BOOL fOk = FALSE; HANDLE hFileSrc = CreateFile(_T("test.txt"),GENERIC_READ,FILE_SHARE_READ,NULL, OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL); HANDLE h...
ST_Overlaps() 函数
天波风客的博客
03-07 426
ST_Overlaps() 函数
重叠I/O类 代码
06-19
在Windows中，重叠I/O主要通过`OVERLAPPED`结构体和`WSAAsyncSelect`或`WSAEventSelect`函数来实现。`OVERLAPPED`结构体包含了用于跟踪I/O操作状态的信息，如偏移量和句柄等。`WSAAsyncSelect`用于将套接字与窗口...
采用事件通知形式的重叠I/O操作模型
01-28
重叠I/O（Overlapped I/O）是Windows操作系统中的一种高效I/O操作模型，它允许数据传输与其他处理任务在同一个线程中并发执行，从而提高系统资源利用率和程序性能。这种模型通常与事件通知机制结合，如Windows的内核...
C++实现采用事件通知的socket重叠I/O模型代码
01-28
本文将深入探讨如何使用C++实现采用事件通知的socket重叠I/O模型，这一模型在处理大量并发连接时具有显著优势。 首先，我们需要理解“重叠I/O”（又称异步I/O）的概念。在传统的同步I/O模型中，一个调用会阻塞直到I...
介绍当前Windows支持的各种Socket I/O模型
11-25
介绍当前Windows支持的各种Socket I/O模型 select WSAAsyncSelect WSAEventSelect Overlapped I/O（重叠IO模型），IOCP模型，有代码详细分析过程
windows TCP/IP 网络编程（六）5种windows网络模型(4) 重叠IO模型(b)完成例程 DEMO
04-12
windows TCP/IP 网络编程（六）5种windows网络模型(4) 重叠IO模型(b)完成例程 DEMO
Windows 网络编程(2)--重叠I/0模型
xingkongyingke的专栏
04-23 897
5).重叠I/O模式(overlapped)常用函素: 1.WSASocket : 创建套接字 2.TCP WSASend WSARecv 3.UDP: WSASendTo WSARecvFrom 4.AccepEx (Mswsock.lib库导出) WSAIoctl 5.数据类型 WSAOVERLAPPED (wsaoverlapped) 函数: WSAGet
四.Windows I/O模型之重叠IO(overlapped)模型
dixiao3078的博客
11-11 281
1.适用于除Windows CE之外的各种Windows平台.在使用这个模型之前应该确保该系统安装了Winsock2.重叠模型的基本设计原理是使用一个重叠的数据结构，一次投递一个或多个Winsock I/O请求。在重叠模型中，收发数据使用WSA开头的函数。2.WSA_FLAG_OVERLAPPED标志:要使用重叠模型。在创建套接字的时候，必须加上该标志。SOCKET s=WSASocke...
Windows Socket五种I/O模型
junecau的专栏
03-19 1594
<br /> <br /> Windows Socket五种I/O模型Winsock 的I/O操作：<br /><br />1、 两种I/O模式 <br />阻塞模式：执行I/O操作完成前会一直进行等待，不会将控制权交给程序。套接字 默认为阻塞模式。可以通过多线程技术进行处理。 <br />非阻塞模式：执行I/O操作时，Winsock函数会返回并交出控制权。这种模式使用 起来比较复杂，因为函数在没有运行完成就进行返回，会不断地返回 WSAEWOULDBLOCK错误。但功能强大。<br />为了解决这个问题，
windows网络编程之重叠模型（OVERLAPPED I/O）基础知识
Timeinsist的博客
06-12 1697
重叠模型 overlapped I/O 重叠 I/O 模型 异步
WINDOWS重叠IO模型
Mr_SGQ的专栏
05-18 8264
一. 重叠IO模型简介 重叠IO的核心实际上就是一个重叠的数据结构。应用程序在单个套接字上投递一个或者多个IO操作，当IO操作完成时对应的重叠数据结构中的事件对象会受信，相应的应用程序通过查事件对象可以得到通知。就这样，通过重叠的数据结构将异步的IO和程序连接起来了。    重叠数据结构：   typedef struct _OVERLAPPED{       DWORD Int
重叠IO模型
学而时习之 不亦乐乎
09-18 3631
比起阻塞、select、WSAAsyncSelect以及WSAEventSelect等模型，重叠I/O(Overlapped I/O)模型使应用程序能达到更佳的系统性能。因为它和这4种模型不同的是，使用重叠模型的应用程序通知缓冲区收发系统直接使用数据 http://blog.163.com/window2008s/blog/static/5440295920087151593603/
[C++ 网络协议] 重叠I/O模型
最新发布
A_ns_wer_的博客
09-28 704
重叠I/O的实现和介绍，以及实现纯重叠I/O的回声服务器端
重叠I/O详解
Barry的博客
11-08 5901
在windows中有一个api叫readfile        bool   readfile(        handle  hfile,                            //   handle  to   file        lpvoid  lpbuffer,                       //   data  buffer
圣天诺加密狗（HASP）破解
ShadowAssassin的专栏
12-12 6293
圣天诺加密狗破解

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值