网络编程——IOCP

最新推荐文章于 2024-05-13 00:31:33 发布
最新推荐文章于 2024-05-13 00:31:33 发布
阅读量2k 收藏 5
点赞数 4
分类专栏： 计算机网络 文章标签： 网络 服务器 windows 多线程 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beilizhang/article/details/124597812
版权

参考

  1. 《TCP/IP网络编程》 尹圣雨

IOCP

IOCP（Input Output Completion Port，输入输出完成端口）是性能最好的Windows平台I/O模型。Linux有epoll，BSD有kqueue。

从重叠I/O理解IOCP

实现非阻塞模式的套接字

在Windows中通过ioctlsocket函数将套接字属性改为非阻塞式，其调用的含义是，将hLisnSock句柄引用的套接字I/O模式（FIONBIO）改为变量mode中指定的形式

SOCKET hLisnSock;
int mode = 1;
......
hListSock = WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
ioctlsocket(hLisnSock, FIONBIO, &mode);
......

其中FIONBIO是用于更改套接字I/O模式的选项，该函数的第三个参数中传入的变量中若有0，则说明套接字是阻塞模式的；如果存有非0值，则说明已将套接字模式改为非阻塞模式。改为非阻塞模式后，除了以阻塞模式进行I/O外，还具有：

  1. 如果在没有客户端连接请求的状态下调用accept函数，将直接返回INVALID_SOCKET。调用WSAGetLastError函数时返回WSAEWOULDBLOCK
  2. 调用accept函数时创建的套接字同样具有非阻塞属性

因此，针对非阻塞套接字调用accept函数并返回INVALID_SOCKET时，应该通过WSAGetLastError函数确认返回INVALID_SOCKET的理由

以纯重叠I/O方式实现回声服务器端
#include <stdio.h>
#include <stdlib.h>
#include <WinSock2.h>

#define BUF_SIZE 1024
void CALLBACK ReadCompRoutine(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);
void CALLBACK WriteCompRoutine(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);
void ErrorHandling(char* message);

typedef struct                                                         // 该结构体中包含套接字句柄、缓冲及缓冲相关信息
{
	SOCKET hClntSock;
	char buf[BUF_SIZE];
	WSABUF wsaBuf;
}PER_IO_DATA, * LPPER_IO_DATA;

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hLisnSock, hRecvSock;
	SOCKADDR_IN lisnAdr, recvAdr;
	LPWSAOVERLAPPED lpOvLp;
	DWORD recvBytes;
	LPPER_IO_DATA hbInfo;
	int mode = 1, recvAdrSz, flagInfo = 0;

	if (argc != 2)
	{
		printf("Usage: %s <port>\n", argv[0]);
		exit(1);
	}

	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
	{
		ErrorHandling("WSAStartup() error!");
	}

	hLisnSock = WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
	ioctlsocket(hLisnSock, FIONBIO, &mode);                           // 该为非阻塞模式

	memset(&lisnAdr, 0, sizeof(lisnAdr));
	lisnAdr.sin_family = AF_INET;
	lisnAdr.sin_addr.s_addr = htonl(INADDR_ANY);
	lisnAdr.sin_port = htons(atoi(argv[1]));

	if (bind(hLisnSock, (SOCKADDR*)&lisnAdr, sizeof(lisnAdr)) == SOCKET_ERROR)
	{
		ErrorHandling("bind() error");
	}
	if (listen(hLisnSock, 5) == SOCKET_ERROR)
	{
		ErrorHandling("listen() error");
	}

	recvAdrSz = sizeof(recvAdr);
	while (1)
	{
		SleepEx(100, TRUE);                                           // alertable状态
		hRecvSock = accept(hLisnSock, (SOCKADDR*)&recvAdr, &recvAdrSz);
		if (hRecvSock == INVALID_SOCKET)                              // 特殊处理accept返回值
		{
			if (WSAGetLastError() == WSAEWOULDBLOCK)
			{
				continue;
			}
			else
			{
				ErrorHandling("accept() error");
			}
		}
		puts("Client connected......");

		lpOvLp = (LPWSAOVERLAPPED)malloc(sizeof(WSAOVERLAPPED));      // 每个客户端都需要独立的结构体变量
		memset(lpOvLp, 0, sizeof(WSAOVERLAPPED));

		hbInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
		hbInfo->hClntSock = (DWORD)hRecvSock;
		(hbInfo->wsaBuf).buf = hbInfo->buf;
		(hbInfo->wsaBuf).len = BUF_SIZE;

		lpOvLp->hEvent = (HANDLE)hbInfo;                              // 基于CR函数的重叠I/O模型中不需要事件对象，可以用来写入其他信息
		WSARecv(hRecvSock, &(hbInfo->wsaBuf), 1, &recvBytes, &flagInfo, lpOvLp, ReadCompRoutine);
	}
	closesocket(hRecvSock);
	closesocket(hLisnSock);
	WSACleanup();
	return 0;
}

void CALLBACK ReadCompRoutine(DWORD dwError, DWORD szRecvBytes, LPWSAOVERLAPPED lpOverlapped, DWORD flags)
{
	LPPER_IO_DATA hbInfo = (LPPER_IO_DATA)(lpOverlapped->hEvent);
	SOCKET hSock = hbInfo->hClntSock;
	LPWSABUF bufInfo = &(hbInfo->wsaBuf);
	DWORD sentBytes;

	if (szRecvBytes == 0)
	{
		closesocket(hSock);
		free(lpOverlapped->hEvent);
		free(lpOverlapped);
		puts("Client disconnected......");
	}
	else
	{
		bufInfo->len = szRecvBytes;
		WSASend(hSock, bufInfo, 1, &sentBytes, 0, lpOverlapped, WriteCompRoutine);
	}
}

void CALLBACK WriteCompRoutine(DWORD dwError, DWORD szSendBytes, LPWSAOVERLAPPED lpOverlapped, DWORD flags)
{
	LPPER_IO_DATA hbInfo = (LPPER_IO_DATA)(lpOverlapped->hEvent);
	SOCKET hSock = hbInfo->hClntSock;
	LPWSABUF bufInfo = &(hbInfo->wsaBuf);
	DWORD recvBytes;
	int flagInfo = 0;
	WSARecv(hSock, bufInfo, 1, &recvBytes, &flagInfo, lpOverlapped, ReadCompRoutine);
}

void ErrorHandling(char* message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}
客户端
#include <stdio.h>
#include <stdlib.h>
#include <WinSock2.h>
#include <WS2tcpip.h>

#define BUF_SIZE 1024
void ErrorHandling(char* message);

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hSocket;
	SOCKADDR_IN servAdr;
	char message[BUF_SIZE];
	int strLen, readLen;

	if (argc != 3)
	{
		printf("Usage: %s <IP> <port>\n", argv[0]);
		exit(1);
	}
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
	{
		ErrorHandling("WSAStartup() error!");
	}

	hSocket = socket(PF_INET, SOCK_STREAM, 0);
	if (hSocket == INVALID_SOCKET)
	{
		ErrorHandling("socket() error");
	}

	memset(&servAdr, 0, sizeof(servAdr));
	servAdr.sin_family = AF_INET;
	inet_pton(AF_INET, argv[1], &servAdr.sin_addr);
	servAdr.sin_port = htons(atoi(argv[2]));

	if (connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
	{
		ErrorHandling("connect() error!");
	}
	else
	{
		puts("Connected......");
	}

	while (1)
	{
		fputs("Input message(Q to quit): ", stdout);
		fgets(message, BUF_SIZE, stdin);
		if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
		{
			break;
		}
		
		strLen = strlen(message);
		send(hSocket, message, strLen, 0);
		readLen = 0;
		while (1)
		{
			readLen += recv(hSocket, &message[readLen], BUF_SIZE - 1 - readLen, 0);
			if (readLen >= strLen)
			{
				break;
			}
		}
		message[strLen] = 0;
		printf("Message from server: %s", message);
	}
	
	closesocket(hSocket);
	WSACleanup();
	return 0;
}

void ErrorHandling(char* message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}
从重叠I/O模型到IOCP

上述重叠I/O模型回声服务器端，重复调用非阻塞模式的accept函数和以进入alertable wait状态为目的的SleepEx函数将影响性能。既不能为了处理连接请求而只调用accept函数，也不能为了Completion Routine而只调用SleepEx函数，因此轮流调用了非阻塞模式的accept函数和SleepEx函数

可以考虑，让main线程（main函数内部）调用accept函数，再单独创建1个线程负责客户端I/O。这就是IOCP的服务器端模型。IOCP将创建专用的I/O线程，该线程负责与所有客户端进行I/O

理解IOCP不要把焦点集中于线程，而是注意：

  1. I/O是否以非阻塞模式工作
  2. 如何确定非阻塞模式的I/O是否完成

实现IOCP

IOCP中已完成的I/O信息将注册到完成端口对象（Completion Port，CP对象）。首先需要经过套接字和CP对象之间的连接请求。为此，需要：

  1. 创建完成端口对象
  2. 建立完成端口对象和套接字之间的联系
创建完成端口
#include <windows.h>

HANDLE CreateIoCompletionPort(HANDLE FileHandle, HANDLE ExistingCompletionPort, ULONG_PTR CompletionKey, DWORD NumberOfConcurrentThreads);

成功时返回CP对象句柄，失败时返回NULL。其中：

  1. FileHandle：创建CP对象时传递INVALID_HANDLE_VALUE
  2. ExistingCompletionPort：创建CP对象时传递NULL
  3. CompletionKey：创建CP对象时传递0
  4. NumberOfConcurrentThreads：分配给CP对象的用于处理I/O的线程数。如果为0，系统中的CPU个数就是可同时运行的最大线程数

示例：

HANDLE hCpObject;
......
hCpObject = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 2);
连接完成端口对象和套接字

该功能同样由CreateIoCompletionPort函数实现

#include <windows.h>

HANDLE CreateIoCompletionPort(HANDLE FileHandle, HANDLE ExistingCompletionPort, ULONG_PTR CompletionKey, DWORD NumberOfConcurrentThreads);

成功时返回CP对象句柄，失败时返回NULL。其中：

  1. FileHandle：要连接到CP对象的套接字句柄
  2. ExistingCompletionPort：要连接套接字的CP对象句柄
  3. CompletionKey：传递已完成I/O相关信息
  4. NumberOfConcurrentThreads：无论传递何值，只要第二个参数非NULL就会忽略

示例：

HANDLE hCpObject;
SOCKET hSock;
......
CreateIoCompletionPort((HANDLE)hSock, hCpObject, (DWORD)ioInfo, 0);

调用CreateIoCompletionPort函数后，只要针对hSock的I/O完成，相关信息就将注册到hCpObject指向的CP对象

确认CP中注册的已完成的I/O
#include <windows.h>

BOOL GetQueuedCompletionStatus(HANDLE CompletionPort, LPDWORD lpNumberOfBytes, PULONG_PTR lpCompletionKey, LPOVERLAPPED* lpOverlapped, DWORD dwMilliseconds);

成功时返回TRUE，失败时返回FALSE。其中：

  1. CompletionPort：注册有已完成I/O信息的CP对象句柄
  2. lpNumberOfBytes：用于保存I/O过程中传输的数据大小的变量地址值
  3. lpCompletionKey：用于保存CreateIoCompletionPort函数的第三个参数值的变量地址值
  4. lpOverlapped：用于保存调用WSASend、WSARecv函数时传递的OVERLAPPED结构体地址的变量地址值
  5. dwMilliseconds：超时信息，超过该指定时间后将返回FALSE并跳出函数。传递INFINITE时，程序将阻塞，直到已完成I/O信息写入CP对象

GetQueuedCompletionStatus由处理IOCP中已完成I/O的线程调用，在I/O完成且已注册相关信息时返回（如果最后一个参数传递INFINITE）

实现基于IOCP的回声服务器端

#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <WinSock2.h>
#include <Windows.h>

#define BUF_SIZE 100
#define READ 3
#define WRITE 5

typedef struct                                               // 保存与客户端相连套接字
{
	SOCKET hClntSock;
	SOCKADDR_IN clntAdr;
}PER_HANDLE_DATA, * LPPER_HANDLE_DATA;

typedef struct                                               // 将I/O中使用的缓冲和重叠I/O中需要的OVERLAPPED结构体变量封装到同一结构体
{
	OVERLAPPED overlapped;
	WSABUF wsaBuf;
	char buffer[BUF_SIZE];
	int rwMode;
}PER_IO_DATA, * LPPER_IO_DATA;

DWORD WINAPI EchoThreadMain(LPVOID CompletionPortIO);
void ErrorHandling(char* message);

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	HANDLE hComPort;
	SYSTEM_INFO sysInfo;
	LPPER_IO_DATA ioInfo;
	LPPER_HANDLE_DATA handleInfo;

	SOCKET hServSock;
	SOCKADDR_IN servAdr;
	int recvBytes, i, flags = 0;
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
	{
		ErrorHandling("WSAStartup() error!");
	}
	hComPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);           // 创建CP对象
	GetSystemInfo(&sysInfo);
	for (i = 0; i < sysInfo.dwNumberOfProcessors; i++)
	{
		_beginthreadex(NULL, 0, EchoThreadMain, (LPVOID)hComPort, 0, NULL);        // 创建与CPU个数相等的线程
	}

	hServSock = WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
	memset(&servAdr, 0, sizeof(servAdr));
	servAdr.sin_family = AF_INET;
	servAdr.sin_addr.s_addr = htonl(INADDR_ANY);
	servAdr.sin_port = htons(atoi(argv[1]));

	bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr));
	listen(hServSock, 5);

	while (1)
	{
		SOCKET hClntSock;
		SOCKADDR_IN clntAdr;
		int addrLen = sizeof(clntAdr);

		hClntSock = accept(hServSock, (SOCKADDR*)&clntAdr, &addrLen);
		handleInfo = (LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));
		handleInfo->hClntSock = hClntSock;
		memcpy(&(handleInfo->clntAdr), &clntAdr, addrLen);

		CreateIoCompletionPort((HANDLE)hClntSock, hComPort, (DWORD)handleInfo, 0);   // 连接CP对象和套接字。针对该套接字的重叠I/O完成时，已完成的信息将写入连接的CP对象

		ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));                         // 相当于同时准备了WSARecv函数中需要的OVERLAPPED结构体变量、WSABUF结构体变量和缓冲
		memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
		ioInfo->wsaBuf.len = BUF_SIZE;
		ioInfo->wsaBuf.buf = ioInfo->buffer;
		ioInfo->rwMode = READ;                                                       // 需要额外的变量区分2种I/O
		WSARecv(handleInfo->hClntSock, &(ioInfo->wsaBuf), 1, &recvBytes, &flags, &(ioInfo->overlapped), NULL);  // 第六个参数相当于传入了PER_IO_DATA结构体变量地址值
	}
	return 0;
}

DWORD WINAPI EchoThreadMain(LPVOID pComPort)
{
	HANDLE hComPort = (HANDLE)pComPort;
	SOCKET sock;
	DWORD bytesTrans;
	LPPER_HANDLE_DATA handleInfo;
	LPPER_IO_DATA ioInfo;
	DWORD flags = 0;

	while (1)
	{
		GetQueuedCompletionStatus(hComPort, &bytesTrans, (LPDWORD)&handleInfo, (LPOVERLAPPED*)&ioInfo, INFINITE);  // 第3个和第4个参数分别得到CreateIoCompletionPort传入的第3个参数和WSARecv或WSASend传入的第2个参数
		sock = handleInfo->hClntSock;

		if (ioInfo->rwMode == READ)
		{
			puts("message received!");
			if (bytesTrans == 0)
			{
				closesocket(sock);
				free(handleInfo);
				free(ioInfo);
				continue;
			}

			memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
			ioInfo->wsaBuf.len = bytesTrans;
			ioInfo->rwMode = WRITE;
			WSASend(sock, &(ioInfo->wsaBuf), 1, NULL, 0, &(ioInfo->overlapped), NULL);      // 将收到的消息发送给客户端

			ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
			memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
			ioInfo->wsaBuf.len = BUF_SIZE;
			ioInfo->wsaBuf.buf = ioInfo->buffer;
			ioInfo->rwMode = READ;
			WSARecv(sock, &(ioInfo->wsaBuf), 1, NULL, &flags, &(ioInfo->overlapped), NULL);  // 接收客户端消息
		}
		else
		{
			puts("message sent!");
			free(ioInfo);
		}
	}
	return 0;
}

void ErrorHandling(char* message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}
cqu_shuai
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows下的IOCP模型（一）：介绍与简单使用
Summer_night_star的博客
10-16 9279
一、IOCP简介 IOCP（I/O Completion Port，I/O完成端口）是Windows操作系统中伸缩性最好的一种I/O模型。     I/O完成端口是应用程序使用线程池处理异步I/O请求的一种机制。处理多个并发异步I/O请求时，使用I/O完成端口比在I/O请求时创建线程更快更高效。 二、IOCP的优势     I/O完成端口可以充分利用Windows内核来进行I/O调度，相较于传统的Winsock模型，IOCP在机制上有明显的优势。 模型 机制 特性 select模型 通过
网络编程——UDP
22岁,是学生的博客
04-08 86
UDP——用户数据报协议, 与TCP协议不同, UDP的连接是不可信的. 数据发送的成功与失败 与 数据报是无关的. 需要用到两个类： 数据报套接字: DatagramSocket——用于发送 与 接收数据包的Socket //构造方法 DatagramSocket(int port); //常用方法 close() : 关闭套接字. send(DatagramPacket dp) : 将一个数据包dp 发送出去 receive(DatagramPacket dp) : 接收一个数据包, 并存储到参
IOCP技术详解
StarWang的博客
08-26 4392
这几周我接触了Windows网络通讯中的IOCP模型,自己在网上找了相关的知识进行学习，自己又下了好多服务器端的代码，但都运行不了，也是自己菜，能力还需加强。幸好我师父资助了我一个能运行的服务端IOCP代码，自己参照网上的相关知识后又与这个能运行的代码做了参照，算是勉强理解了构造IOCP的一般方法，对IOCP的使用也有了很大的心得。接下来我就把自己对IOCP相关知识的理解记录下来，方便自己以后的复习，当然这篇文章如果对正在阅读的你有帮助也算是很好的。...
2024年C C++最全Win-服务器端 IOCP模型_one-thread-per-client，2024年最新25岁成功入职阿里P7的小哥哥告诉你
最新发布
2401_84978565的博客
05-13 264
4、必须在监听socket上投递AcceptEx请求（mswsock.dIl mswsock.lib等）5、Worker线程干的事情：使用GetQueuedCompletionStatus()监控完成端口。3、创建一个用于监听socket，绑定到完成端口上，然后开始在指定的端口上监听客户端连接请求。1、创建一个完成端口CreateIoCompletionPort()等待线程队列(WaitingThreadList-LIFO)6、当接收到AcceptEx通知时 _DoAccept0。4、完成端口实现流程。
什么是IOCP
weixin_40301728的博客
07-19 3701
关于什么是IOCP的描述
网络编程学习3：IOCP模型
字节跳动
07-23 356
IOCP模型 IOCP(I/O completion port，I/O完成端口）是伸缩性最好的一种I/O模型。 I/O完成端口是应用程序使用线程池处理异步I/O请求的一种机制。处理多个并发异步I/O请求时，使用I/O完成端口比在I/O请求时创建线程更快更有效。 I/O完成端口最初的设计时应用程序发出一些异步I/O请求，当这些请求完成时，设备驱动将把这些工作项目排序到完成端口，这样，在完成端口上等待的线程池便可以处理这些完成I/O。 完成端口实际上时一个Windows I/O结构，它可以接收多个对象的句柄，如
[C++ 网络协议] IOCP（Input Output Completion Port）
A_ns_wer_的博客
10-07 987
IOCP的介绍
网络编程——TCP
wzf_Cql
09-22 137
一、socket 什么是socket？ SOCKET称为套接字，它就可以看成一个文件接口，也可以看成一个文件。套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。 socket函数： int socket(int domain, int type, int protocol)， 它会创建一个套接字描述符，套接字描述符是属于件描述符的一种
mfc 网络编程iocp实例
11-15
本文将深入探讨MFC网络编程中的一个重要概念——IOCP（I/O完成端口），并结合提供的"mfc 网络编程iocp实例"进行详细解析。 IOCP（I/O完成端口）是Windows操作系统内核提供的一种高效、可扩展的I/O模型，特别适用于...
EchoSvr.rar_网络编程_Visual_C++_
08-12
《基于IOCP的Windows网络编程——Visual C++实现》 在计算机编程领域，网络编程是一项核心技能，尤其在分布式系统和互联网应用中更是不可或缺。本文将深入探讨一个使用Visual C++开发的基于IOCP（I/O完成端口）的...
test.zip_网络编程_Visual_C++_
08-11
此外，考虑到网络的异步特性，可能还需要使用多线程或者异步编程模型，如Windows的IOCP（I/O完成端口）来处理并发的网络请求，以提高程序的响应性和效率。 总的来说，"test.zip"中的项目展示了如何在Visual C++环境...
Socket.rar_网络编程_Visual_C++_
08-12
9. **网络编程模型**：除了基本的同步阻塞模型，还有异步非阻塞模型（如I/O复用模型，如select、poll、epoll）、事件驱动模型（如Windows的WSAAsyncSelect或epoll）和回调模型（如Windows的IOCP）等，它们各有优缺点...
lserver.rar_网络编程_Visual_C++_
08-11
《基于TCP协议的简单聊天软件实现——Visual C++网络编程详解》 在计算机科学领域，网络编程是一项核心技能，尤其对于开发跨平台通信应用的程序员来说。本教程将聚焦于使用Visual C++进行网络编程，具体是实现一个...
c++——iocp模型
www_dong的博客
07-07 4937
IOCP有一个队列，当你要发数据时，收数据和连接时，都交由IOCP队列处理，不会与操作系统底层交互。 　该函数实际用于两个明显有别的目的： 5.4.3 向IOCP队列投递接受连接的请求 5.4.4 检测队列，从队列中取出完成的请求 5.4.5 投递一个队列完成状态 6. 示例 服务端 客户端...
IOCP详解
铭毅天下Elasticsearch
12-25 6941
IOCP详解 IOCP（I/O Completion Port，I/O完成端口）是性能最好的一种I/O模型。它是应用程序使用线程池处理异步I/O请求的一种机制。在处理多个并发的异步I/O请求时，以往的模型都是在接收请求是创建一个线程来应答请求。这样就有很多的线程并行地运行在系统中。而这些线程都是可运行的，Windows内核花费大量的时间在进行线程的上下文切换，并没有多少时间花在线程运行上。再加上
IOCP简单了解
m0_46486963的博客
08-03 460
IOCP是Input/Output Completion Ports的简称，中文翻译为完成端口，完成是应用程序向系统发起一个IO操作，系统会在操作结束后，将IO操作完成结果通知应用程序，端口指的是机制。
IOCP完成端口通俗讲义与项目实战
jaye8090的博客
04-02 2583
可以把IOCP完成端口理解为Windows下性能最高的网络编程技术，本文讲解该技术的基本知识，以及如何使用该技术开发高性能的网络软件。 IOCP完成端口本质上就是Windows提供的一种请求队列+通知队列，我们把各种耗时的网络操作请求投递到请求队列，系统具体怎么去完成这些网络操作我们不管，系统完成后会把结果放到通知队列里，我们就去通知队列里获取结果然后处理。............................................................................
完成端口(IOCP)编程探讨
08-31 1586
 FW: http://www.zhuaxia.com/item/473350387完成端口(IOCP)编程探讨2007-08-26 16:06:00来自：C++博客-首页原创精华区   新建目录...根目录新手试用频道          本文主要探讨一下windows平台上的完成端口开发及其与之相关的几个重要的技术概念，这些概念都是与基于IOCP的开发

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值