IOCP 学习例子

最新推荐文章于 2024-02-18 21:19:30 发布
最新推荐文章于 2024-02-18 21:19:30 发布
阅读量782 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： c++ iocp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ab7936573/article/details/51132045
本文提供了一个IOCP（完成端口）的学习实例，详细介绍了IOCP的相关知识点，包括编程注意事项，以及在使用WSASend和WSARecv时遇到WSA_IO_PENDING情况的解析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

IOCP完成端口例子代码:

// IoPort.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <WinSock2.h>
#pragma comment(lib,"ws2_32.lib")
#include "Win32NetWork.h"
#include <ws2tcpip.h>  
#include <mswsock.h>    //微软扩展的类库

typedef BOOL (* LPFN_AcceptEx) (       
               SOCKET sListenSocket,   
               SOCKET sAcceptSocket,   
               PVOID lpOutputBuffer,   
               DWORD dwReceiveDataLength,   
               DWORD dwLocalAddressLength,   
               DWORD dwRemoteAddressLength,   
               LPDWORD lpdwBytesReceived,   
               LPOVERLAPPED lpOverlapped   
);  


CWin32NetWork netWork;

#define LISTIEN 1
#define ACCEPT 2
#define SEND 3
#define SENDED 4
#define RECV 5
#define RECVED 6
#define CLOSE 7

#define DATA_LENGTH 1024

typedef struct PER_IO_DATA {
	SOCKET client;
	OVERLAPPED overlapped;
	INT OperatorType;
	int nUseLength;
	int dataLength;
	char dataBuffer[DATA_LENGTH];
}PER_IO_DATA,*LPPER_IO_DATA;

int GetSysCoreCount(){
	SYSTEM_INFO si; 
	GetSystemInfo(&si); 
	return si.dwNumberOfProcessors;  
}

void FreeIoData(LPPER_IO_DATA IoData){
	if(IoData != NULL){
		if(IoData->client != NULL)closesocket(IoData->client);
		//GlobalFree(IoData);
		free(IoData);
	}
}

LPFN_ACCEPTEX     lpfnAcceptEx = NULL;         // AcceptEx函数指针
void InitAcceptEx(SOCKET sock){
	if(lpfnAcceptEx == NULL){
		GUID GuidAcceptEx = WSAID_ACCEPTEX;        // GUID，这个是识别AcceptEx函数必须的  
		DWORD dwBytes = 0;    
		WSAIoctl(  
			sock,   
			SIO_GET_EXTENSION_FUNCTION_POINTER,   
			&GuidAcceptEx,   
			sizeof(GuidAcceptEx),   
			&lpfnAcceptEx,   
			sizeof(lpfnAcceptEx),   
			&dwBytes,   
			NULL,
			NULL);
	}
}

DWORD WINAPI WorkerThread(LPVOID lpParam){
	HANDLE ioPort = lpParam;
	const char *strMsgState = "Hello,how are you?";
	while(true){
		OVERLAPPED  *pOverlapped = NULL;
		DWORD   dwBytesTransfered = 0;
		void *lpContext = NULL; 
		BOOL bRet = GetQueuedCompletionStatus(ioPort,  
								 &dwBytesTransfered,  
								 (LPDWORD)&lpContext,  
								 &pOverlapped,  
								 /*INFINITE*/ 5*1000);
		if(bRet == FALSE){
			//IO端口异常关闭
			if(GetLastError() == ERROR_INVALID_HANDLE) break;
			//超时
			if(dwBytesTransfered == 0 && pOverlapped == NULL) continue;
			//对端异常关闭
			dwBytesTransfered = 0;
		}
		PER_IO_DATA* pIoContext = CONTAINING_RECORD(pOverlapped, PER_IO_DATA, overlapped);
		if (0 == dwBytesTransfered)
		{
			printf("关闭连接:%d\n",pIoContext->client);
			FreeIoData(pIoContext);
			continue;
		}
		int nError = 0;
		switch(pIoContext->OperatorType){
		case ACCEPT:
			printf("接受连接:%d\n",pIoContext->client);
			//将新的客户套接字与完成端口连接
			pIoContext->OperatorType = RECV;         //状态设置成接收
			if(dwBytesTransfered != -1) pIoContext->nUseLength = dwBytesTransfered;
			PostQueuedCompletionStatus(ioPort,dwBytesTransfered,(ULONG_PTR)pIoContext,&(pIoContext->overlapped));
			break;
		case RECV:
			{
				DWORD Flags = 0;
				DWORD RecvBytes = 0;
				pIoContext->OperatorType = RECVED;
				WSABUF DataBuf;
				DataBuf.len= pIoContext->dataLength - pIoContext->nUseLength;
				DataBuf.buf= pIoContext->dataBuffer + pIoContext->nUseLength;
				ZeroMemory(pIoContext->dataBuffer,pIoContext->dataLength);
				int nRet = WSARecv(pIoContext->client,&DataBuf,1,
					&RecvBytes,&Flags,&(pIoContext->overlapped),NULL);
				int nRecvLen = strlen(pIoContext->dataBuffer);
				if(nRet ==SOCKET_ERROR){
					nError = WSAGetLastError();
					//端口PENDING则等待
					if(WSA_IO_PENDING == nError){
						break;
					}else{
						//关闭端口
						pIoContext->OperatorType = CLOSE;
						PostQueuedCompletionStatus(ioPort,0,(ULONG_PTR)pIoContext,&(pIoContext->overlapped));
						break;
					}
				}
			}
			break;
		case RECVED:
			pIoContext->OperatorType = SEND;
			pIoContext->nUseLength += dwBytesTransfered==-1?0:dwBytesTransfered;
			PostQueuedCompletionStatus(ioPort,pIoContext->nUseLength,(ULONG_PTR)pIoContext,&(pIoContext->overlapped));
			break;
		case SEND:
			{
				DWORD SendBytes = 0;
				pIoContext->OperatorType = SENDED;
				WSABUF DataBuf;
				if(pIoContext->nUseLength == 0){
					DataBuf.len= strlen(strMsgState);
					DataBuf.buf= (CHAR*)strMsgState;
				}else{
					DataBuf.len= pIoContext->nUseLength;
					DataBuf.buf= pIoContext->dataBuffer;
				}
				int nRet = WSASend(pIoContext->client,&DataBuf,1,&SendBytes,0,&(pIoContext->overlapped),NULL);
				if(nRet ==SOCKET_ERROR){
					//端口PENDING则等待
					nError = WSAGetLastError();
					if(WSA_IO_PENDING == nError){
						if(pIoContext->nUseLength == 0){
							//心跳检测失败则关闭端口
							pIoContext->OperatorType = CLOSE;
							PostQueuedCompletionStatus(ioPort,0,(ULONG_PTR)pIoContext,&(pIoContext->overlapped));
							break;
						}
						break;
					}else {
						//关闭端口
						pIoContext->OperatorType = CLOSE;
						PostQueuedCompletionStatus(ioPort,0,(ULONG_PTR)pIoContext,&(pIoContext->overlapped));
						break;
					}
				}
			}
			break;
		case SENDED:
			pIoContext->OperatorType = RECV;
			pIoContext->nUseLength = 0;
			ZeroMemory(pIoContext->dataBuffer,pIoContext->dataLength);
			PostQueuedCompletionStatus(ioPort,-1,(ULONG_PTR)pIoContext,&(pIoContext->overlapped));
			break;
		case CLOSE:
		default:
			printf("关闭连接:%d\n",pIoContext->client);
			FreeIoData(pIoContext);
		}
	}
	return 0;
}
DWORD WINAPI ServerProcess(HANDLE ioPort,HANDLE ioClient){
	while(true){
		OVERLAPPED  *pOverlapped = NULL;  
		DWORD   dwBytesTransfered = 0;
		void *lpContext = NULL; 
		BOOL bRet = GetQueuedCompletionStatus(ioPort,  
								 &dwBytesTransfered,  
								 (LPDWORD)&lpContext,  
								 &pOverlapped,  
								 INFINITE);
		if(bRet == FALSE){
			if(GetLastError() == ERROR_INVALID_HANDLE) break;
			else continue;
		}
		PER_IO_DATA* pIoContext = CONTAINING_RECORD(pOverlapped, PER_IO_DATA, overlapped);
		int nError = 0;
		if(dwBytesTransfered == 0 && 
			(pIoContext->OperatorType == RECV ||  pIoContext->OperatorType == SEND)
		){
			FreeIoData(pIoContext);
		}else
		if(pIoContext->OperatorType == ACCEPT){
			CreateIoCompletionPort((HANDLE)pIoContext->client,
				ioClient,(ULONG_PTR)pIoContext,0);
			PostQueuedCompletionStatus(ioClient,dwBytesTransfered,(ULONG_PTR)pIoContext,&(pIoContext->overlapped));
			break;
		}
	}
	return 0;
}
bool ProcessAcceptEx(LPPER_IO_DATA perIoData,SOCKET sock)
{
	perIoData->client = WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,0,0,WSA_FLAG_OVERLAPPED);
	DWORD dwBytes = 0;
	BOOL bRet = lpfnAcceptEx(sock,perIoData->client,perIoData->dataBuffer,perIoData->dataLength-((sizeof(SOCKADDR_IN)+16)*2),
		sizeof(SOCKADDR_IN)+16,sizeof(SOCKADDR_IN)+16,&dwBytes,&(perIoData->overlapped));
	if(bRet == FALSE){
		int nError = WSAGetLastError();
		if(nError == ERROR_IO_PENDING){
			//正确
		}else if(nError == WSAECONNRESET){
			return false;
		}else if(nError == WSAEINVAL){
			return false;
		}else{
			return false;
		}
	}
	return true;
}
int _tmain(int argc, _TCHAR* argv[])
{
	//服务器地址
	struct sockaddr_in my_addr = {0};
	my_addr.sin_family = AF_INET;
	my_addr.sin_port = htons(23000);
	my_addr.sin_addr.s_addr = INADDR_ANY;

	//开启重叠端口并监听
    SOCKET sock = WSASocket(AF_INET,SOCK_STREAM,0,NULL,0,WSA_FLAG_OVERLAPPED);
	int on = 1;
	int ret = setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on) );
	int nError = 0;
	int nRet = bind(sock,(const sockaddr*)&my_addr,sizeof(struct sockaddr_in));
	nRet!=SOCKET_ERROR?nRet = listen(sock,100):0;
	if(nRet == SOCKET_ERROR){
		nError = WSAGetLastError();
		closesocket(sock);
		return -1;
	}
	HANDLE ioClient = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL, NULL,0);

	//开启服务线程
	bool bInitWorkThread = false;
	if(bInitWorkThread == false){
		for(int i = 0; i < GetSysCoreCount()*2;i++){
			HANDLE hHandle = CreateThread(NULL,0,WorkerThread,ioClient,0,NULL);
			if(hHandle != NULL) CloseHandle(hHandle);
		}
		bInitWorkThread = true;
	}

	//创建完成端口
	HANDLE ioPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL, NULL,0);
	//绑定完成端口
	LPPER_IO_DATA perDandleData = {0};
    perDandleData = (LPPER_IO_DATA)GlobalAlloc(GPTR,sizeof(LPPER_IO_DATA));
	perDandleData->OperatorType = LISTIEN;
    CreateIoCompletionPort((HANDLE)sock,ioPort,(ULONG_PTR)perDandleData,0);
	//初始化接受函数
	InitAcceptEx(sock);
	
	while(true){
		//准备完成端口参数
		LPPER_IO_DATA pIoContext = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));//GlobalAlloc(GPTR,sizeof(PER_IO_DATA));
		if(pIoContext == NULL){
			printf("No Enoufy Memory!\n");
			Sleep(100);
			continue;
		}
		ZeroMemory(pIoContext,sizeof(struct PER_IO_DATA));
        pIoContext->OperatorType = ACCEPT;
        pIoContext->dataLength = DATA_LENGTH;
		//accept接受连接方式
		pIoContext->client = accept(sock,NULL,NULL);
		CreateIoCompletionPort((HANDLE)pIoContext->client,
				ioClient,(ULONG_PTR)pIoContext,0);
		PostQueuedCompletionStatus(ioClient,-1,(ULONG_PTR)pIoContext,&(pIoContext->overlapped));
		/*
		//AcceptEx接受连接方式
		bool bRet = ProcessAcceptEx(pIoContext,sock);
		if(bRet == false) break;
		ServerProcess(ioPort,ioClient);
		*/
	}
	FreeIoData(perDandleData);
	CloseHandle(ioPort);
	CloseHandle(ioClient);
	closesocket(sock);
	return 0;
}
Win32NetWork.h 

#ifndef WIN32NETWORK_H
#define WIN32NETWORK_H

//#include <WinSock.h>
#pragma comment(lib,"ws2_32.lib")
class CWin32NetWork{
public:
	CWin32NetWork(){
		WSADATA wsa_data;
		WSAStartup(0x0202, &wsa_data);
	}
};

#endif

查错IOCP资料说明:

IOCP相关的一些总结

IOCP编程注意事项

IOCP中在WSASend以及WSARecv的时候出现WSA_IO_PENDING情况的说明

完整的IOCP实例
06-01
应该是网上最完成的IOCP实例吧。NT6线程池，VS2010。
微软提供IOCP例子
08-27
IOCP的例子对于理解其工作原理和学习如何在实际项目中应用至关重要。通过分析和运行这些示例，开发者可以深入理解如何利用IOCP来优化多线程环境下的I/O操作，提升服务性能，尤其是在高并发的网络服务器开发中。因此...
IOCP的例子
mimong_lin的专栏
04-05 2123
以前在书上看过了IOCP，不过一直都没有写过代码。现在写的时候，着时对很多问题摸不着头脑。不过好在优快云上有许多的对于IOCP问题的讨论帖，让我受益非浅啊，也把心中的一些迷茫解开了，下面给出的是可以运行的IOCP的C/S代码，自已试了在一个机器上开了一百来个客户端，跑起来暂时没出现问题（因为通信内容太简单了^-^)。IOCP的三个函数：CreateIoCompletionPort、GetQu
iocp例子
FRcheng的专栏
11-02 715
//socket的简单封装CDSocket.h #include #define BUFFER_SIZE 1024 #define OP_READ 1 #define OP_WRITE 2 #define OP_ACCEPT 3 struct SockInit { SockInit() { WSADATA wsaData; WSAStartup(MAKEWORD(2, 2)
iocp简单例子
最新发布
计算机王的博客
02-18 784
完整例子复制就可以用，注释全，无任何坑，iocp简单例子（有带网络的iocp与纯iocp的使用例子）、控制台事件例子（有控制台键盘、鼠标、关闭事件）、控制台界面设置
IOCP简单例子
03-23 206
Server: View Code {*******************************************************}{ }{ IOCP Server Sample ...
C#下IOCP简单例子.rar
03-27
总结来说，这个"C#下IOCP简单例子"是一个学习和理解IOCP如何在C#中应用的宝贵资源。通过研究和运行这个示例，开发者能够深入了解如何利用IOCP提升网络I/O性能，这对于开发高性能的服务器应用尤其有价值。
openssl 结合 IOCP的例子
11-23
本文将详细解析"openssl 结合 IOCP的例子"，这是一份使用OpenSSL库进行加密通信，并结合Windows操作系统的I/O完成端口（IOCP，Input/Output Completion Port）技术实现高性能网络服务的示例。 OpenSSL是一个开源...
学习iocp的例子学习iocp的例子
01-26
学习IOCP的例子可以帮助你深入理解异步I/O在Windows上的实现，以及如何在实际项目中应用这些技术来提高网络服务的性能和响应能力。通过分析`IocpDemo`中的代码，你可以看到如何组织和管理IOCP相关的结构，以及如何...
一个很好的完成端口（IOCP）例子
09-03
完成端口（IOCP，即I/O完成...综上所述，这个IOCP的例子是一个学习和实践网络编程，尤其是高性能服务器端设计的重要资源。通过研究和运行这些代码，开发者可以深入理解如何利用完成端口优化网络服务的性能和可伸缩性。
Windows IOCP实例 - 改编自PiggyXP
10-10
使用VS2015 unicode重新编译，新增了服务端回传数据的功能，压测客户端增加了实际压测的功能，并统计显示QPS
windows IOCP示例代码
12-07
使用Windows提供的IOCP技术，以及系统线程池，实现Windows服务器端对大并发的长连接的支持。
一个简单的完成端口例子（IOCPDemo）适合初学者参考
09-04
一个简单的完成端口例子（IOCPDemo）适合初学者参考
iocp简单例子，对初学者非常有利
04-20
对初学者非常有帮助，可以完成一个服务器对2500个客户端的通信，只需要开处理器个数*2个线程就可以实现，通信效率非常高。
IOCP例子
浓浓的巧克力
04-15 3079
//#include "stdafx.h" #include using namespace std; #include #include #include #include #define PORT 5150 #define DATA_BUFSIZE 8192 typedef struct {     OVERLAPPED OVerlapped;
一个IOCP 例子
chcucl的专栏
10-11 2317
IOCP 例子 翻译人: Kevin Chen.  原文链接：http://www.codeproject.com/KB/IP/iocp_server_client.aspx  1. 简介     2. IOCP 2.1. 异步完成端口(IOCP)简介          一个服务器程序如果不能同时服务多个客户端，则不能称之为服务程序，通常，异步I/O调用和多线程被用来实现同
IOCP 浅析与实例
风铃中的刀声
01-12 8297
转载：http://www.cppfans.org/1267.html   这一年半来一直在做游戏项目逻辑层，学会了不少东西，觉得自己应该看看服务器底层的东西了，主要的东西就是网络模块，网络模块是沿用以前项目的，在 我们项目中被我们头改动过几次，现在还是比较稳定的。因为是Windows平台，所以用的依然是被大多数人神话了的IOCP，不过的确IOCP 表现的非常不错。 什么是IOCP？ 众所
IOCP简单示例
heri1的博客
09-20 444
// TestIOCP.cpp : 定义控制台应用程序的入口点。 //   #include "stdafx.h" #include #include #include using namespace std; #pragma  comment(lib, "ws2_32.lib") #pragma  comment(lib, "kernel32.lib")
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值