WinSock 重叠I/O模型

最新推荐文章于 2021-01-05 00:41:46 发布
最新推荐文章于 2021-01-05 00:41:46 发布
阅读量1.2k 收藏
点赞数
分类专栏： 网络编程 C/C++ Windows程序设计 文章标签： socket 服务器 null winapi buffer server
  
//服务端
/*
。在程序清单7-8 中，我们向大家展示了如何构建一个简单
的服务器应用，令其采用前述的方法，通过完成例程，来实现对一个套接字请求的管理。该程序的编
码主要按下述步骤进行：

① 新建一个套接字，开始在指定端口上，监听一个进入的连接。

② 接受一个进入的连接请求。

③ 为接受的套接字创建一个WSAOVERLAPPED 结构。

④ 在套接字上投递一个异步WSARecv 请求，方法是将WSAOVERLAPPED 指定成为参数，同时提供
一个完成例程。

⑤ 在将fAlertable 参数设为TRUE 的前提下，调用WSAWaitForMultipleEvents，并等待一个重
叠I/O 请求完成。重叠请求完成后，完成例程会自动执行，而且WSAWaitForMultipleEvents 会返回一
个WSA_IO_COMPLETION。在完成例程内，可随一个完成例程一道，投递另一个重叠WSARecv 请求。

⑥ 检查WSAWaitForMultipleEvents 是否返回WSA_IO_COMPLETION。
⑦ 重复第⑤步和第⑥步。

程序清单7-8 采用完成例程的简单重叠I/O 处理示例
// 说明：该例介绍了如何使用重叠I/O 模型开发简单的回显服务器应用，该例也是简单的控制
台程序，

  */
// 它会在连接从服务器建立和移除时打印消息。该应用会在5150 端口监听和接收进入的TCP 连
//接，
// 收到客户端发送的数据时，会把收到的数据按照原来的格式发送回去



// 编译：cl -o overlap overlap.cpp ws2_32.lib
#include <winsock2.h>
#include <windows.h>
#include <stdio.h>


#pragma comment(lib,"ws2_32.lib") 

#define PORT 5150
#define DATA_BUFSIZE 8192


typedef struct _SOCKET_INFORMATION {
	CHAR Buffer[DATA_BUFSIZE];   
	WSABUF DataBuf;
	SOCKET Socket;
	WSAOVERLAPPED Overlapped;
	DWORD BytesSEND;
	DWORD BytesRECV;
} SOCKET_INFORMATION, * LPSOCKET_INFORMATION;




DWORD EventTotal = 0;   //事件对象总数

DWORD WINAPI ProcessIO(LPVOID lpParameter);

WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];

LPSOCKET_INFORMATION SocketArray[WSA_MAXIMUM_WAIT_EVENTS];   

CRITICAL_SECTION CriticalSection;


int main(void)
{
	WSADATA wsaData;

	SOCKET ListenSocket, AcceptSocket;

	SOCKADDR_IN InternetAddr;

	DWORD Flags;

	DWORD ThreadId;

	DWORD RecvBytes;

	INT Ret;

	InitializeCriticalSection(&CriticalSection);   //初始化临界区

	printf("主函数开始执行\n") ;

	if ((Ret = WSAStartup(0x0202,&wsaData)) != 0)
	{
		printf("WSAStartup failed with error %d\n", Ret);
		WSACleanup();
		return 0 ;
	}
	if ((ListenSocket = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0,
		WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET)  //创建监听端口
	{
		printf("Failed to get a socket %d\n", WSAGetLastError());
		return 0 ;
	}
	
	InternetAddr.sin_family = AF_INET;
	InternetAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	InternetAddr.sin_port = htons(PORT);

	if (bind(ListenSocket, (PSOCKADDR) &InternetAddr, sizeof(InternetAddr)) ==
		SOCKET_ERROR)  //绑定端口
	{
		printf("bind() failed with error %d\n", WSAGetLastError());
		return 0 ;
	}
	if (listen(ListenSocket, 5))
	{
		printf("listen() failed with error %d\n", WSAGetLastError());
		return  0 ;
	}


	// 建立连接的监听套接字
	if ((AcceptSocket = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0,
		WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET)   //这里创建了一个异步的
	{
		printf("Failed to get a socket %d\n", WSAGetLastError());
		return  0 ;
	}

	if ((EventArray[0] = WSACreateEvent()) == WSA_INVALID_EVENT)  //第一个事件对象
	{
		printf("WSACreateEvent failed with error %d\n", WSAGetLastError());
		return  0 ;
	}
	// 创建服务重叠请求的线程
	printf("创建线程\n") ;
	if (CreateThread(NULL, 0, ProcessIO, NULL, 0, &ThreadId) == NULL)  //为什么不叫ThreadIO,也叫ProcessIO咧？
	{
		printf("CreateThread failed with error %d\n", GetLastError());
		return  0 ;
	}

	EventTotal = 1;  //突然间冒出来


	int i = 0 ;
	while(TRUE)
	{
		// 接收进入的连接
		
		printf("Main第%d次循环\n",i+1) ;

		i++ ;

		printf("等待连接,兼进入临界区\n") ;
		if ((AcceptSocket = accept(ListenSocket, NULL, NULL)) == INVALID_SOCKET)
		{
			printf("accept failed with error %d\n", WSAGetLastError());
			return 0 ;
		}


		
		EnterCriticalSection(&CriticalSection);   //临界区？？




		// 创建同接收的套接字相关的套接字信息结构体
		if ((SocketArray[EventTotal] = (LPSOCKET_INFORMATION) GlobalAlloc(GPTR,
			sizeof(SOCKET_INFORMATION))) == NULL)
		{
			printf("GlobalAlloc() failed with error %d\n", GetLastError());
			return 0 ;
		}
		// 填充接收套接字的细节
		SocketArray[EventTotal]->Socket = AcceptSocket;  //新套接字的？

		ZeroMemory(&(SocketArray[EventTotal]->Overlapped), sizeof(OVERLAPPED)); 

		SocketArray[EventTotal]->BytesSEND = 0;

		SocketArray[EventTotal]->BytesRECV = 0;

		SocketArray[EventTotal]->DataBuf.len = DATA_BUFSIZE;

		SocketArray[EventTotal]->DataBuf.buf = SocketArray[EventTotal]->Buffer;

		if ((SocketArray[EventTotal]->Overlapped.hEvent = EventArray[EventTotal] =
			WSACreateEvent()) == WSA_INVALID_EVENT)    //将第几个事件对象赋给
		{
			printf("WSACreateEvent() failed with error %d\n", WSAGetLastError());
			return  0;
		}
		// 发布WSARecv 请求开始在套接字上接收数据
		Flags = 0;

		if (WSARecv(SocketArray[EventTotal]->Socket,
			&(SocketArray[EventTotal]->DataBuf), 1, &RecvBytes, &Flags,
			&(SocketArray[EventTotal]->Overlapped), NULL) == SOCKET_ERROR)
		{
			if (WSAGetLastError() != ERROR_IO_PENDING)
			{
				printf("WSARecv() failed with error %d\n", WSAGetLastError());
				return 0;
			}
		}

		EventTotal++;

		printf("离开临界区\n") ;
		LeaveCriticalSection(&CriticalSection);

		// 信号通知事件数组中的第一个事件，让工作线程服务事件数组中的其它事件
		if (WSASetEvent(EventArray[0]) == FALSE)
		{
			printf("WSASetEvent failed with error %d\n", WSAGetLastError());
			return  0 ;
		}



	}//while


	return 0 ;
}

DWORD WINAPI ProcessIO(LPVOID lpParameter)
{
	DWORD Index;
	
	DWORD Flags;
	
	LPSOCKET_INFORMATION SI;
	
	DWORD BytesTransferred;
	
	DWORD i;
	
	DWORD RecvBytes, SendBytes;
	
	printf("进入ProcessIO\n") ;
	
	int j = 0 ;
	// 处理异步WSASend、WSARecv 请求
	while(TRUE)
	{
		
		printf("ProcessIO第%d次循环\n",j+1) ;
		j++ ;
		
		
		if ((Index = WSAWaitForMultipleEvents(EventTotal, EventArray, FALSE,
			WSA_INFINITE, FALSE)) == WSA_WAIT_FAILED)
		{
			printf("WSAWaitForMultipleEvents failed %d\n", WSAGetLastError());
			return 0;
		}
		// 如果触发的事件为零，然后会在我们的监听套接字上进行连接尝试
		if ((Index - WSA_WAIT_EVENT_0) == 0)  //如果是0的话，就直接跳到下一个循环？什么回事？
		{
			WSAResetEvent(EventArray[0]);
			continue;
		}
		
		SI = SocketArray[Index - WSA_WAIT_EVENT_0];
		
		WSAResetEvent(EventArray[Index - WSA_WAIT_EVENT_0]);
		
		if (WSAGetOverlappedResult(SI->Socket, &(SI->Overlapped), &BytesTransferred,
			FALSE, &Flags) == FALSE || BytesTransferred == 0)
		{
			printf("Closing socket %d\n", SI->Socket);
			if (closesocket(SI->Socket) == SOCKET_ERROR)
			{
				printf("closesocket() failed with error %d\n", WSAGetLastError());
			}
			GlobalFree(SI);
			
			WSACloseEvent(EventArray[Index - WSA_WAIT_EVENT_0]);
			
			// 通过删除事件句柄和套接字信息结构体来清除SocketArray 和EventArray
			
			
			EnterCriticalSection(&CriticalSection);  //临界区。。
			
			
			
			
			if ((Index - WSA_WAIT_EVENT_0) + 1 != EventTotal)
				for (i = Index - WSA_WAIT_EVENT_0; i < EventTotal; i++)
				{
					EventArray[i] = EventArray[i + 1];
					SocketArray[i] = SocketArray[i + 1];
				}
				
				EventTotal--;
				
				LeaveCriticalSection(&CriticalSection);  //离开临界区
				continue;
		}
		// 查看BytesRECV 域是否为0，然后这意味着WSARecv 调用刚刚完成，因此可以用从已完
		//成
		// 的WSARecv 调用中获得的BytesTransferred 值来更新 BytesRECV 域
		if (SI->BytesRECV == 0)
		{
			SI->BytesRECV = BytesTransferred;
			SI->BytesSEND = 0;
		}
		else
			
		{
			SI->BytesSEND += BytesTransferred;
		}
		
		if (SI->BytesRECV > SI->BytesSEND)
		{
			// 发布另一个WSASend()请求，因为WSASend()不能确保发送所以请求的字节，继续
			//发布
			// WSASend()调用直到所以收到的字节被发送
			ZeroMemory(&(SI->Overlapped), sizeof(WSAOVERLAPPED));
			SI->Overlapped.hEvent = EventArray[Index - WSA_WAIT_EVENT_0];
			SI->DataBuf.buf = SI->Buffer + SI->BytesSEND;
			SI->DataBuf.len = SI->BytesRECV - SI->BytesSEND;
			if (WSASend(SI->Socket, &(SI->DataBuf), 1, &SendBytes, 0,
				&(SI->Overlapped), NULL) == SOCKET_ERROR)  //这里发出去
			{
				if (WSAGetLastError() != ERROR_IO_PENDING)
				{
					printf("WSASend() failed with error %d\n", WSAGetLastError());
					return 0;
				}
			}
		}
		else
		{
			SI->BytesRECV = 0;
			// 现在不在需要发布WSARecv 请求来发送其余的数据
			Flags = 0;
			
			ZeroMemory(&(SI->Overlapped), sizeof(WSAOVERLAPPED));
			
			SI->Overlapped.hEvent = EventArray[Index - WSA_WAIT_EVENT_0];
			
			SI->DataBuf.len = DATA_BUFSIZE;
			
			SI->DataBuf.buf = SI->Buffer;
			
			if (WSARecv(SI->Socket, &(SI->DataBuf), 1, &RecvBytes, &Flags,
				&(SI->Overlapped), NULL) == SOCKET_ERROR)  //接收事件
			{
				if (WSAGetLastError() != ERROR_IO_PENDING)
				{
					printf("WSARecv() failed with error %d\n", WSAGetLastError());
					return 0;
				}
			}
			else
			{
			//	printf("接收: %s",SI->DataBuf ) ; 一次是接收不完的
			}
		}
		}
		
		printf("离开ProcessIO\n") ;
}


 

 

 



//客户端
/*

程序清单6-2 是客户端代码，客户端建立一个套接字，并对投入应用的服务器名进行解析，然后
与服务器建立连接。连接一旦建成，就可发送大量的消息了。每次发送数据之后，客户端都会等待服
务器发回的回应。客户端把得自套接字的数据打印出来。
回应客户端和服务器不能完全说明TCP 协议的流式传输。这是因为读取操作是在写操作之后进行
的，至少客户端这一端是这样的。当然，对服务器来说，还有另一种方式。因此，服务器每次调用读
取函数，一般都会返回客户端发出的整条消息。但不要误会，如果客户端的消息大到超过了TCP 的最
大传输单元，在线上，它会被分成几个小的数据包，这种情况下，接收端需要多次执行接收调用，才
能收完整条消息。为了更好地说明流式传输，运行客户端和服务器时带上-O 选项即可。这样，客户端
便只管发送数据，接收端只管读取数据。

		  
			
服务器如下执行：
server -p:5150 -o
而客户端如下执行：
client -p:5150 -s:IP -n:10 -o
大家最可能见到的是客户端进行了10 次send 调用，而服务器在一次或两次recv 调用中，就读
取了10 条消息。


*/



//程序清单6-2 回应客户端代码


// 说明：回显客户端，连接TCP 服务器，发送数据，并且读服务器返回的数据
// 编译命令：cl -o Client Client.c ws2_32.lib
//
// 命令行参数：
// client [-p:x] [-s:IP] [-n:x] [-o]
// -p:x 发送的远程端口
// -s:IP 服务器IP 地址或主机名
// -n:x 发送消息次数
// -o 只发送消息，不接收
//

#include <winsock2.h>
#include <stdio.h>
#include <stdlib.h>

#pragma  comment(lib, "Ws2_32.lib ")

#define DEFAULT_COUNT 10

#define DEFAULT_PORT 5150

#define DEFAULT_BUFFER 2048

#define DEFAULT_MESSAGE "This is a test of the emergency \
broadcasting system"


char szServer[128], // 连接的服务器

szMessage[1024]; // 发送给服务器的消息

int iPort = DEFAULT_PORT; // 连接到服务器的端口

DWORD dwCount = DEFAULT_COUNT; // 发送消息次数

BOOL bSendOnly = FALSE; // 只发送数据，不接收


 void usage() ;
 void ValidateArgs(int argc, char **argv) ;

// 函数：main
// 说明：执行主线程，初始化Winsock，解释命令行参数，创建套接字，连接服务器，然后发送
//和接
// 收数据
int main(int argc, char **argv)
{
	WSADATA wsd;
	SOCKET sClient;
	char szBuffer[DEFAULT_BUFFER];
	int ret,i;

	struct sockaddr_in server;

	struct hostent *host = NULL;

	// 解释命令行并且载入Winsock
	ValidateArgs(argc, argv);

	if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
	{
		printf("Failed to load Winsock library!\n");
		return 1;
	}
	strcpy(szMessage, DEFAULT_MESSAGE);
	// 创建套接字，并且尝试连接服务器
	sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sClient == INVALID_SOCKET)
	{
		printf("socket() failed: %d\n", WSAGetLastError());
		return 1;
	}
	server.sin_family = AF_INET;
	server.sin_port = htons(iPort);
	server.sin_addr.s_addr = inet_addr(szServer);
	
		// 如果提供的服务器地址不是形如"aaa.bbb.ccc.ddd"，则为主机名，尝试解析它
		if (server.sin_addr.s_addr == INADDR_NONE)
		{
			host = gethostbyname(szServer);
			if (host == NULL)
			{
				printf("Unable to resolve server: %s\n", szServer);
				return 1;
			}

			CopyMemory(&server.sin_addr, host->h_addr_list[0],
				host->h_length);
		}
		if (connect(sClient, (struct sockaddr *)&server,sizeof(server)) == SOCKET_ERROR)
		{
			printf("connect() failed: %d\n", WSAGetLastError());
			return 1;
		}

		// 发送和接收数据
		for(i = 0; i < dwCount; i++)
		{
			ret = send(sClient, szMessage, strlen(szMessage), 0);
			if (ret == 0)
				break;
			else if (ret == SOCKET_ERROR)
			{
				printf("send() failed: %d\n", WSAGetLastError());
				break;
			}
			printf("Send %d bytes\n", ret);
			if (!bSendOnly)
			{
				ret = recv(sClient, szBuffer, DEFAULT_BUFFER, 0);
				if (ret == 0) // Graceful close
					break;
				else if (ret == SOCKET_ERROR)
				{
					printf("recv() failed: %d\n", WSAGetLastError());
					break;
				}
				szBuffer[ret] = '\0';
				printf("RECV [%d bytes]: '%s'\n", ret, szBuffer);
			}
		}
		closesocket(sClient);
		WSACleanup();
		return 0;
}




 void usage()
{
	printf("usage: client [-p:x] [-s:IP] [-n:x] [-o]\n\n");
	printf(" -p:x Remote port to send to\n");
	printf(" -s:IP Server's IP address or hostname\n");
	printf(" -n:x Number of times to send message\n");
	printf(" -o Send messages only; don't receive\n");
	ExitProcess(1);
}


// 函数：ValidateArgs
// 说明：解释命令行参数，设置全局变量
void ValidateArgs(int argc, char **argv)
{
	int i;
	for(i = 1; i < argc; i++)
	{
		if ((argv[i][0] == '-') || (argv[i][0] == '/'))
		{
			switch (tolower(argv[i][1]))
			{
			case 'p': // Remote port
				if (strlen(argv[i]) > 3)
					iPort = atoi(&argv[i][3]);
				break;
				
			case 's': // Server
				if (strlen(argv[i]) > 3)
					strcpy(szServer, &argv[i][3]);
				break;
			case 'n': // Number of times to send message
				if (strlen(argv[i]) > 3)
					dwCount = atol(&argv[i][3]);
				break;
			case 'o': // Only send message; don't receive
				bSendOnly = TRUE;
				break;
			default:
				usage();
				break;
			}
		}
	}
}


 

劉俊
关注
专栏目录
[C++ 网络协议] 重叠I/O模型
A_ns_wer_的博客
09-28 818
重叠I/O的实现和介绍，以及实现纯重叠I/O的回声服务器端
网络程序设计——重叠I/O模型
最新发布
x20020402的博客
11-27 962
对于网络重叠I/O操作，等待I/O操作结束的另一种方法是使用完成例程。异步的发送和接收接口函数的参数中的最后一个参数lpCompletionROUTINE就是用来指向完成例程的指针。若指定此参数，hEvent参数将被忽略，上下文信息将传送给完成例程函数。如果重叠操作立即完成，则返回0；如果重叠操作被成功初始化，并且稍后完成，则返回WSA_IO_PENDING。WinSock可以使用事件通知和完成例程两种方式来实现重叠I/O的操作。（3）两种获取传输数据数量的方法。
WinSock重叠I/O模型
曾梦想仗剑走天涯
12-27 5981
一．重叠I/O模型的概念当调用ReadFile()和WriteFile()时，如果最后一个参数lpOverlapped设置为NULL，那么线程就阻塞在这里，直到读写完指定的数据后，它们才返回。这样在读写大文件的时候，很多时间都浪费在等待ReadFile()和WriteFile()的返回上面。如果ReadFile()和WriteFile()是往管道里读写数据，那么有可能阻塞得更久，导致程序性能下
WinSock重叠IO模型一
走出憧憬的专栏
05-29 4320
  WinSock的重叠IO模型也就是重叠IO的一个特例罢了。其实就是把套接字当成文件来操作。在重叠IO中，如果读大文件的时候，为了不在那里干等。告诉系统，我先去下两盘象棋，你读完了，告诉我一下。下棋时窗口是全屏的，读完后，弹一个对话框出来告诉我下吧。恩，下棋，真是浪费时间的事，得戒掉啊。   WinSock中的重叠模型也是如此，告诉系统，有人发数据过来的时候通知我哈。我现在干点别的事太无聊了
windows socket网络编程五：重叠IO模型
c++小白的博客
01-05 1627
文章目录分析事件通知重叠IO结构体创建支持重叠IO的socket投递异步Accept投递异步Recv投递异步Send询问事件获取重叠信号分类处理运行结果完成例程投递异步Accept投递异步Recv投递异步Send分类处理运行结果模型流程图源码链接 分析 在解决了select模型本身的同步阻塞问题后，我们还要处理send、recv、accept的执行阻塞。 我们socket的操作本质上都是字符串的拷贝复制，重叠IO是windows提供的一种异步读写文件的机制，将读的指令以及我们的buffer投给操作系统，然后
关于Winsock：重叠的I / O和事件对象
一世豁然的专栏
10-12 373
Windows套接字2支持重叠I / O，所有传输提供程序都支持此功能。 重叠I / O遵循Windows中建立的模型，可以在使用套接字函数创建的套接字上执行，也可以使用WSASocket函数创建的套接字执行，并在dwFlags参数中设置WSA_FLAG_OVERLAPPED标志。 注意 使用重叠属性创建套接字对套接字当前是处于阻塞还是非阻塞模式没有影响。 使用重叠属性创建的套接字可用于执行...
WinSock I/O 模型 -- OVERLAPPED I/O 模型
Useless Programmer 的专栏
11-14 486
简介 OVERLAPPED I/O 模型也是 WinSock 中常见的异步 I/O 模型，相比于我们之前提到的 Select 模型，WSAAsyncSelect 模型 和 WSAEventSelect 模型有更好的性能. 为了方便描述，下文我们将称 Overlapped I/O 模型为 “重叠模型”. 重叠模型的基本设计原理便是让应用程序使用一个 重叠的数据结构(Overlapped)，一次投递一个或多个 Winsock I/O 请求。针对那些提交的请求，在它们完成 之后，应用程序可为它们提供服务 使用这个
C++实现采用事件通知的socket重叠I/O模型代码
01-28
本文将深入探讨如何使用C++实现采用事件通知的socket重叠I/O模型，这一模型在处理大量并发连接时具有显著优势。 首先，我们需要理解“重叠I/O”（又称异步I/O）的概念。在传统的同步I/O模型中，一个调用会阻塞直到I...
基于重叠IO模型的 回显TCP服务器设计
weixin_34403693的博客
10-14 109
---------------------1 套接字对象---------------------- 为每个套接字创建一个SOCKET_OBJ对象，记录与之相关的信息。 typedef struct _SOCKET_OBJ{ SOCKET s; int nOutstandingOps;//重叠IO数量 LPFN_ACCEPTEX lpfnAcceptEx; ...
WIN网络编程-重叠I/0服务器设计
深未来技术
12-21 362
///////////////////////////////////////////////////////// OverlappedServer.cpp文件//基于重叠I/0模型的简单的回显TCP服务器，它接受客户端连接之后，将从客//户端接收到的数据再发送给客户端。本例采用了单线程。//使用重叠I/O模型必须使用WSASocket函数创建套接字,传送数据使用//WSASend
基于重叠I/O模型的服务器实践(以事件驱动)
Datura_Metel的博客
04-18 388
服务器端#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...
TCP/IP网络编程_基于Windows的编程_第22章重叠I/O模型
weifc-wei 的博客
06-18 288
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 所示, 同一线程内.
windows Socket编程之重叠IO模型
Timmiy的博客
08-14 6227
上一篇文章我们讲了EventSelect网络模型，它已经解决了等待数据到来的这一大部分时间，但是它还有一小部分时间没有节省下来。那就是把数据从网卡的缓冲区拷贝到我们应用程序的缓冲区里边。而这一篇的重叠IO模型就是将这一小部分的时间也给节省了下来。
手把手教你玩转SOCKET模型之重叠I/O篇
zy122的专栏
01-04 1356
前 言 其实我首先应该道歉，因为7月份的时候曾信誓旦旦的说要写一套关于SOCKET所有模型的入门文章以及配套代码，不过没想到后天竟然被美女所迷出去度假了，刚刚回来不久。。。。。。-_-b其实那些模型的配套代码我已经基本写完了，只是没写配套文字，不过我想还是先从稍微难一点的模型写起吧，因为其他模型的入门毕竟要简单一些。 不过由于也是初学者，疏漏之处还望不吝指正。 本文凝聚着笔者心血，如要转载，请指明
WinSock 重叠IO模型
Masimaro的专栏
06-29 617
之前介绍的WSAAsyncSelect和WSAEvent模型解决了收发数据的时机问题，但是网卡这种设备相比于CPU和内存来说仍然是慢速设备，而调用send和recv进行数据收发操作仍然是同步的操作，即使我们能够在恰当的时机调用对应的函数进行收发操作，但是仍然需要快速的CPU等待慢速的网卡。这样仍然存在等待的问题，这篇博文介绍的重叠IO模型将解决这个等待的问题 重叠IO简介 一般接触重叠...
Winsock I/O模型详解：从阻塞到异步与重叠I/O
在Windows操作系统中，Winsock（Windows Socket）提供了一套API接口，包括多种I/O模型，以支持不同的应用程序需求和性能优化。 1. **Winsock I/O模式**： - **阻塞模式**：这是默认的I/O模式，在执行I/O操作（如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值