WindowsAPI 查阅笔记：进程间管道通信

已于 2024-08-14 11:06:02 修改
阅读量862 收藏 19
点赞数 15
分类专栏： Windows 编程 文章标签： 笔记 winAPI 管道
于 2024-08-13 20:01:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/orange1710/article/details/141163764
版权

进程间有名管道的通信：

1.1 重叠I/O（Overlapped I/O）

重叠I/O（Overlapped I/O）是Windows编程中的一种异步 I / O 处理方式，它允许程序在发出I/O请求后继续执行其他任务，而不必等待I/O操作完成。这种机制通过使用OVERLAPPED结构体和相关的异步I/O函数（如ReadFileEx、WriteFileEx等）来实现。

在重叠I/O中，OVERLAPPED结构体用于存储I/O操作的上下文信息。它包含以下成员：

typedef struct _OVERLAPPED {
    ULONG_PTR   Internal;		//一个指向内部缓冲区的指针。
    ULONG_PTR   InternalHigh;	//内部缓冲区的高位地址。
    HANDLE      hEvent;			//一个用于异步操作的事件对象。
} OVERLAPPED, *LPOVERLAPPED;

当程序发出一个异步I/O请求时，它会将OVERLAPPED结构体的地址作为参数传递给异步I/O函数。异步I/O函数会在后台执行I/O操作，并在操作完成时通过设置事件对象或完成端口来通知程序。程序可以在任何时间点检查事件对象或完成端口的状态，以确定I/O操作是否已完成，并处理操作的结果。

重叠I/O通常用于需要高性能和响应能力的应用程序，如数据库服务器、文件服务器等。它允许这些应用程序在等待I/O操作完成的同时处理其他任务，从而提高系统的吞吐量和整体性能。

请注意，使用重叠I/O需要小心处理错误和资源管理。程序必须确保在异步I/O操作完成后正确地关闭事件对象和句柄，以避免资源泄漏和其他潜在问题。此外，程序还需要正确处理异步I/O操作的结果，包括检查错误代码和处理读取或写入的数据。

1.2 异步 I/O

同步 I / O ，指的是调用 ReadFile、WriteFile 等函数进行输入输出时候，系统完全执行该函数后才继续执行接下来的代码。
异步 I / O ，指的是调用 ReadFile、WriteFile 等函数之后，函数立即返回，线程可以进行其他操作。剩下的I/O操作再系统内核中自动完成。
再系统内核完成出入输出后，程序如何知道I/O已经完成：通过【完全函数】

1.3 完全函数

【完全函数】，如果使用 ReadFileEx、WriteFileEx等进行 I/O ，可以指定完全函数，所谓【完全函数】指的是内核完成 I/O 之后，内核会自动回调这个函数。当【完全函数】被调用时候，就指明内核已经完成了 I/O，程序可以再这个函数中进行一个 I/O 完成后需要的操作（例如释放内存）。

1.3 代码

  • 服务端创建了一个异步I/O管道，

  • 服务端 CompletedWriteRoutine 和 CompletedReadRoutine 两个函数互为对方的【完全代码】

  • 服务端 一开始创建了，一个【事件】，客户端连接成功后打开，否则等待。

  • 客户端通过管道名连接有名管道。

服务端：

#include <windows.h>
#include <cstdio>
#include <tchar.h>
#include <stdlib.h>

//常量 
#define PIPE_TIMEOUT 5000
#define BUFSIZE 4096

//结构定义 
typedef struct{
	OVERLAPPED oOverlap;
	HANDLE hPipeInst;
	TCHAR chRequest[BUFSIZE];
	DWORD cbRead;
	TCHAR chReply[BUFSIZE];
	DWORD cbToWrite;
} PIPEINST, *LPPIPEINST;

//函数声明
VOID DisconnectAndClose(LPPIPEINST);
BOOL CreateAndConnectInstance(LPOVERLAPPED);
BOOL ConnectToNewClient(HANDLE, LPOVERLAPPED);
VOID GetAnswerToRequest(LPPIPEINST);
VOID WINAPI CompletedWriteRoutine(DWORD, DWORD, LPOVERLAPPED);
VOID WINAPI CompletedReadRoutine(DWORD, DWORD, LPOVERLAPPED);

//全局变量
HANDLE hPipe;

/***********
pipe 通信服务端主函数 
***********/ 
int main(void)
{
	HANDLE hConnectEvent;
	OVERLAPPED oConnect;
	LPPIPEINST lpPipeInst;
	DWORD dwWait, cbRet;
	BOOL fSuccess, fPendingIO;
	
	//用于连接操作的事件对象
	hConnectEvent = CreateEvent(
		NULL,	//默认属性
		TRUE,	//手工reset
		TRUE,	//初始状态 signaled
		NULL	//未命名 
	);
	if(hConnectEvent == NULL){
		printf("CreateEvent failed with %d.\n",
			GetLastError());
		return 0;
	}
	//OVERLAPPED 事件
	oConnect.hEvent = hConnectEvent;
	// 创建连接实例，等待连接
	fPendingIO = CreateAndConnectInstance(&oConnect);
	while(1)
	{
		//等待客户端连接或读写操作完成
		dwWait = WaitForSingleObjectEx(
			hConnectEvent,	//等待的事件
			INFINITE,		//无限等待
			TRUE);
		switch(dwWait){
			case 0:
				//pending
				if(fPendingIO){
					//获取 Overlapped I/O 的结果
					fSuccess = GetOverlappedResult(
						hPipe,		//pipe句柄
						&oConnect,	//OVERLAPPED结构 
						&cbRet,		//已经传送的数据量
						FALSE 		//不等待 
					);
					if(!fSuccess){
						printf("ConnectNamedPipe (%d)\n", GetLastError());
						return 0;
					} 
				}
				
				//分配内存
				lpPipeInst = (LPPIPEINST)HeapAlloc(GetProcessHeap(), 0, sizeof(PIPEINST));
				if(lpPipeInst == NULL){
					printf("GlobalAlloc failed (%d)\n", GetLastError());
					return 0;
				}
				lpPipeInst->hPipeInst = hPipe;
				//读和写，注意CompleteWriteRoutine 和 CompletedReadRoutine 的相互调用
				lpPipeInst->cbToWrite = 0;
				CompletedWriteRoutine(0, 0, (LPOVERLAPPED) lpPipeInst);
				//先创建一个连接实例，以响应下一个客户端的连接
				fPendingIO = CreateAndConnectInstance(&oConnect);
				break;
				//读写完成
			case WAIT_IO_COMPLETION:
				break;
			default:{
				printf("WaitForSingleObjectEx (%d)\n", GetLastError());
				return 0;
			} 
		}
	} 
	return 0;
}

 
/*************************
建立连接实例
返回值 是否成功 
**********************/ 
BOOL CreateAndConnectInstance(LPOVERLAPPED lpoOverlap)
{
//	LPTSTR lpszPipename = _T("\\\\.\\pipe\\samplenamedpipe");
	TCHAR lpszPipename[64] = TEXT("\\\\.\\pipe\\samplenamedpipe");
	//创建 named pipe
	hPipe = CreateNamedPipe(
		lpszPipename,			//pipe名 
		
		PIPE_ACCESS_DUPLEX | 	//可读可写
		FILE_FLAG_OVERLAPPED,	//重叠I/O 模式
		//pipe模式
		PIPE_TYPE_MESSAGE |		//消息类型 pipe
		PIPE_READMODE_MESSAGE | //消息读模式
		
		PIPE_WAIT,				//阻塞模式
		PIPE_UNLIMITED_INSTANCES,	//无限制实例
		BUFSIZE*sizeof(TCHAR),	//输出缓存大小
		BUFSIZE*sizeof(TCHAR),	//输入缓存大小
		PIPE_TIMEOUT,			//客户端超时 
		NULL					//默认安全属性 
	);
	if(hPipe == INVALID_HANDLE_VALUE){
		printf("CreateNamedPipe failed with %d.\n",
			GetLastError());
		return 0;
	}
	//连接到新的客户端
	return ConnectToNewClient(hPipe, lpoOverlap); 
}

/************************
建立连接实例
返回值 是否成功 
**********************/ 

BOOL ConnectToNewClient(HANDLE hPipe, LPOVERLAPPED lpo)
{
	BOOL fConnected, fPendingIO = FALSE;
	//开始一个 overlapped 连接
	fConnected = ConnectNamedPipe(hPipe, lpo);
	if(fConnected){
		printf("ConnectNamedPipe failed with %d.\n",
			GetLastError());
		return 0;
	} 
	switch(GetLastError()){
		//overlapped 连接进行中
		case ERROR_IO_PENDING:
			fPendingIO = TRUE;
			break;
			//已经连接，因此 Event 未置位
		case ERROR_PIPE_CONNECTED:
			if(SetEvent(lpo->hEvent)){
				break;
			} 
			//error
		default:{
			printf("ConnectNamePipe failed with %d.\n",
				GetLastError());
			return 0;
		}
	}
	
	return fPendingIO;
} 

/*************************
写入pipe操作的完成函数
当写操作完成时候被调用,开始读另一个请求 
*************************/

void WINAPI CompletedWriteRoutine(
	DWORD dwErr,
	DWORD cbWritten,
	LPOVERLAPPED lpOverLap)
{
	LPPIPEINST lpPipeInst;
	BOOL fRead = FALSE;
	//保存 overlap 实例
	lpPipeInst = (LPPIPEINST) lpOverLap;
	//如果没有错误
	if((dwErr == 0) && (cbWritten == lpPipeInst->cbToWrite))
	{
		fRead = ReadFileEx(
			lpPipeInst->hPipeInst,
			lpPipeInst->chRequest,
			BUFSIZE *sizeof(TCHAR),
			(LPOVERLAPPED) lpPipeInst,
			//写操作完成后，调用CompleteReadRoutine
			(LPOVERLAPPED_COMPLETION_ROUTINE) CompletedReadRoutine); 
	}
	if(! fRead){
		//出错 断开连接
		DisconnectAndClose(lpPipeInst); 
	}
	return ;
}

/*************************
读取pipe操作的完成函数
当写操作完成时候被调用,开始读另一个请求 
*************************/

void WINAPI CompletedReadRoutine(
	DWORD dwErr,
	DWORD cbBytesRead,
	LPOVERLAPPED lpOverLap)
{
	LPPIPEINST lpPipeInst;
	BOOL fWrite = FALSE;
	//保存 overlap 实例
	lpPipeInst = (LPPIPEINST) lpOverLap;
	//如果没有错误
	if((dwErr == 0) && (cbBytesRead != 0))
	{
		//根据客户端的请求，生成回复
		GetAnswerToRequest(lpPipeInst);
		//将回复写入pipe 
		fWrite = WriteFileEx(
			lpPipeInst->hPipeInst,
			lpPipeInst->chReply,
			lpPipeInst->cbToWrite,
			(LPOVERLAPPED) lpPipeInst,
			//写入完成后，调用CompleteWriteRoutine
			(LPOVERLAPPED_COMPLETION_ROUTINE) CompletedWriteRoutine); 
	}
	if(! fWrite){
		//出错 断开连接
		DisconnectAndClose(lpPipeInst); 
	}
	return ;
}

//TODO 根据客户端的请求，给出响应
VOID GetAnswerToRequest(LPPIPEINST pipe)
{
	_tprintf(TEXT("[%d] %s\n"), pipe->hPipeInst, pipe->chRequest);
	lstrcpyn(pipe->chReply, TEXT("Default answer from server"), BUFSIZE);
	pipe->cbToWrite = (lstrlen(pipe->chReply) + 1) * sizeof(TCHAR);
	return ;
} 

/********************
功能 断开一个连接的实例 
*******************/

VOID DisconnectAndClose(LPPIPEINST lpPipeInst)
{
	//关闭连接实例
	if(! DisconnectNamedPipe(lpPipeInst->hPipeInst))
	{
		printf("DisconnectNamePipe failed with %d.\n",
			GetLastError()); 
	} 
	//关闭 pipe 实例的句柄
	CloseHandle(lpPipeInst->hPipeInst);
	//释放
	if(lpPipeInst != NULL){
		HeapFree(GetProcessHeap(), 0, lpPipeInst);
	} 
	return ;
}

客户端：

//PipeClnt.cpp

/**********************
通过 pipe 进行进程间通信 
*********************/

#include <windows.h>
#include <cstdio>
#include <conio.h>
#include <tchar.h>

//常量 
#define BUFSIZE 512

/***********************
pipe 通信服务端主函数 
**********************/
int main(int argc, TCHAR *argv[])
{
	HANDLE hPipe;
	LPTSTR lpvMessage = TEXT("Default message from client");
//	TCHAR lpvMessage[64] = TEXT("Default message from client");
	TCHAR chBuf[BUFSIZE];
	BOOL fSuccess;
	DWORD cbRead, cbWritten, dwMode;
//	LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\samplenamedpipe");
	TCHAR lpszPipename[64] = TEXT("\\\\.\\pipe\\samplenamedpipe");
	
	if(argc > 1){
		//如果输入了参数，则使用输入的参数 
		lpvMessage = argv[1]; 
	}
	while(1){
		
		//打开一个命名 pipe
		hPipe = CreateFile(
			lpszPipename,	//pipe名
			GENERIC_READ | GENERIC_WRITE,	//可读可写
			0,		//不共享
			NULL,	//默认安全属性
			OPEN_EXISTING,	//已经存在（由服务端创建）
			0,		//默认属性
			NULL);
		if(hPipe != INVALID_HANDLE_VALUE){
			break;
		}
		//如果不是 ERROR_PIPE_BUSY 错误，直接退出
		if(GetLastError() != ERROR_PIPE_BUSY){
			printf("Could not open pipe");
			return 0;
		} 
		//如果所有的 pipe 实例都处于繁忙，等待2s
		if(!WaitNamedPipe(lpszPipename, 2000)){
			printf("Could not open pipe");
			return 0;
		} 
	}
	//pipe 已经连接 设置为消息读状态
	dwMode = PIPE_READMODE_MESSAGE;
	fSuccess = SetNamedPipeHandleState(
		hPipe,	//句柄
		&dwMode,	//新状态
		NULL,	//不设置最大缓存
		NULL	//不设置最长时间 
	);
	if(!fSuccess){
		printf("SetNamePipeHandleState failed");
		return 0;
	}
	
	//写入 pipe
	fSuccess = WriteFile(
		hPipe,				//句柄
		lpvMessage,			//写入的内容
		(lstrlen(lpvMessage)+1)*sizeof(TCHAR),//写入内容的长度
		&cbWritten,		//实际写的内容 
		NULL			//非 overlapped 
	);
	if(!fSuccess){
		printf("WriteFile failed");
		return 0;
	}
	
	do{
		//读回复
		fSuccess = ReadFile(
			hPipe,	//句柄
			chBuf,	//读取内容的缓存
			BUFSIZE*sizeof(TCHAR),//缓存大小
			&cbRead,	//实际读的字节
			NULL		//非 overlapped 
		);
		if(!fSuccess && GetLastError() != ERROR_MORE_DATA){
			break;	//失败退出 
		}
		_tprintf(TEXT("%s\n"), chBuf);//打印读的结果 
	}while(!fSuccess);
	
	//任意键退出 
	getch(); 
	//关闭句柄
	CloseHandle(hPipe); 
	return 0;
}

先启动服务端，再启动多个客户端。
运行结果：
在这里插入图片描述

1710orange
关注
专栏目录
【并发编程四】windows进程通信和Linux进程通信
junxuezheng的博客
11-12 1769
原本写完上一篇[【并发编程三】C++进程通信（管道pipe)],就准备写消息队列的c++demo了，但是真正查找资料才发现网上都是linux下的消息队列的c++demo，就没有windows下的消息队列的进程通信的demwindows没有信号这个概念，但是会提供类似功能的api,比如，杀死进程：linux下的kill信号，windows下提供TerminateProcess的api接口。
学习笔记：SpringCloud 微服务技术栈_实用篇①_基础知识
做笔记，记录学习中遇到的问题。
07-14 2172
本博客主要讲述了微服务的远程调用的简单案例、Eureka 注册中心、Nacos 注册中心、Fegin 的远程调用、统一 GateWay、Docker、MQ 消息队列、ElasticSearch 分布式搜索的基础知识。
阿里云学习笔记
Haines
04-02 1622
弹性伸缩（Auto Scaling）是根据业务需求和策略自动调整计算能力（即实例数量）的服务。您可以指定实例的类型，即ECS实例或ECI实例。在业务需求增长时，弹性伸缩自动增加指定类型的实例，来保证计算能力；在业务需求下降时，弹性伸缩自动减少指定类型的实例，来节约成本。弹性伸缩不仅适合业务量不断波动的应用程序，同时也适合业务量稳定的应用程序。部署在伸缩组内ECS实例或ECI实例上的应用必须是无状态并且可横向扩展的。
嵌入式系统及应用Linux学习笔记(六)---进程通信
qq_40700822的博客
06-16 268
进程的通信 fork新的进程完全复制父进程的数据，父子进程直接独立，没有影响 进程与进程间的数据空间是相互独立的 一个进程的代码段只能存取其自己的数据，而不能存取另一个进程的数据 写一个程序测试：用全局变量能否在父子进程直接传递数据？ 定义全局变量 子进程对全局变量操作 父进程对全局 进程通信的目的 A、数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几M字节之间 B、共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。 C、通知事件：一
【Redis】笔记（尚硅谷、黑马整合）
努力充实，远方可期
04-22 9881
笔记内容包括两个视频的笔记： Redis—尚硅谷java研究院 （推荐）Redis入门到精通【黑马程序员】https://www.bilibili.com/video/BV1CJ411m7Gc 第1章 NoSQL 简介 REmote Dictionary Server：是一种用C语言开发的开源的高性能键值对数据库。 1.1 技术的分类 解决功能性的问题 Java、Servlet、Jsp、Tom...
孙鑫 VC++深入详解——学习笔记
只为龙舞的博客
12-04 3121
原文地址：http://blog.csdn.net/xiongxuanwen/article/details/43793953 第1课 Windows程序内部运行机制 1.MFC生成的C++ 源文件中都有 StdAfx.h，此文件包含了常用的AFX函数的声明，其中有 afxwin.h,此文件包含了CRECT,CPoint， CWnd等许多类及其方
服务与进程
灰少の博客
04-27 1187
进程是指在系统中正在运行的一个应用程序；线程是系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元。对于操 作系统而言，其调度单元是线程。一个进程至少包括一个线程，通常将该线程称为主线程。一个进程从主线程的执行开始进而创建一个或多个附加线程，就是所谓基于多线程的多任务。最基本的系统进程列表：smss.exe Session Managercsrss.exe 子系统服务器进程winlo
孙鑫视频VC++深入详解学习笔记
天天water的专栏
11-11 5099
转载自：http://www.cnblogs.com/gaojun/archive/2010/08/15/1800099.html VC++深入详解学习笔记 Lesson1: Windows程序运行原理及程序编写流程 Lesson2: 掌握C++基本语法 Lesson3: MFC框架程序剖析 Lesson4: 简单绘图 Lesson5: 文本编程
python核心编程--笔记（不定时跟新）
wcqlwyt的博客
06-07 800
的解释器options: 1.1 –d 提供调试输出 1.2 –O 生成优化的字节码(生成.pyo文件) 1.3 –S 不导入site模块以在启动时查找python路径 1.4 –
Python面试宝典：Python中与多进程编程相关的面试笔试题（1000加面试笔试题助你轻松捕获大厂Offer）
今晚打老虎的专栏
05-24 453
python中与多进程相关的知识和面试题
最新学习笔记 2022-04-04
qq_40838776的博客
04-10 716
STM32 MP157 华清远见学习笔记 第一章 开发环境要求 Ubuntu 18.04 LTS 64-bit 虚拟机存放硬盘分区剩余空间 80G 以上 第二章 Ubuntu 安装 安装Ubuntu 18.04 配置虚拟机 网络连接修改 Ubuntu 系统安装成功之后，默认网络配置为 NAT 模式，为了后续方便 Ubuntu 与主机进行网络通信需要修改为桥接模式 安装 VMware Tools 使用Open VM Tools安装VMware Tools： 如果您正在运行Ubuntu桌面版，则要安装VMwar
华为云计算HCIE学习笔记-FusionAccess
热门推荐
魔仙堡的仙女的博客
12-22 1万+
华为FusionAccess桌面云解决方案是基于华为云平台的一种虚拟桌面应用，通过在云平台上部署华为桌面云软件，使终端用户通过瘦客户端或者其他设备来访问跨平台的整个客户桌面和应用。 桌面云就是一个桌面池，这个池子中每一个桌面都有一个User来关联，信息靠HDC维护，写在DB中。 FusionAccess就是VDI（虚拟桌面基础设施）Virtual Desktop Infrastructure。FA是实现方式，VDI是一套解决方案。用虚拟桌面来替代物理PC。 物理PC：本地计算/处理，数据local
原js笔记
Pwsifeng的博客
01-10 2541
s原生JS笔记 电话：17339853876（微信同号） 二阶段学习内容 1、B/S架构（web结构） [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4LYi0Arv-1641803458638)(img1628929434621.png)] 2、前端工程师的工作 人机交互 前后端交互 3、HTML、CSS、JS的作用和关系 一个网页由三部分组成：HTML、CSS、Javascript HTML： 结构（静态） [外链图片转存失败,源站可能有防盗链
STM32学习笔记（二、初识stm32单片机）
tommorrowwill的博客
09-10 786
首先stm32是意法半导体公司（ST）使用ARM公司的Cortex-M为核心生产的32位的单片机。其中，ST---意法半导体公司，即SOC厂商。M---为Microelectronics的缩写，即微型处理器。32---表示控制器为32位的。103---表示F系列的子系列。
C++学习笔记----6、内存管理（五）---- 智能指针（3）
weixin_71738303的博客
09-11 1160
与指向特定类型的原始指针可以转化为不同类型的指针一样，shared_ptr保存特定的类型可以转化为一个另一种类型的shared_ptr。转化shared_ptr的函数是const_pointer_cast()，dynamic_pointer_cast(),static_pointer_cast()和reinterpret_pointer_cast()。前面简要提过，当拥有共享属主的智能指针，例如shared_ptr不在活动范围或者被重置时，只有它是最后指向的智能指针时才能释放其指向的资源。
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
最新发布
qq_44189622的博客
09-11 831
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
OJ在线判题系统项目笔记
今天不coding的博客
09-11 771
OJ在线判题系统项目笔记
经验笔记：Web 浏览器存储手段
qq_45831414的博客
09-10 879
以上就是使用 IndexedDB 的基本步骤。IndexedDB 提供了强大的数据存储能力，并且可以通过索引来优化数据检索性能。在实际应用中，可能还需要处理更复杂的场景，比如数据迁移、错误处理等。务必确保你的代码能够妥善处理各种异常情况。
Linux操作系统实验：管道实现进程间通信
"这篇实验报告主要讲述了如何在Linux操作系统中使用管道（pipe）实现两个进程间的通信。实验目的是为了熟悉Linux应用程序开发、进程控制原语的使用，特别是管道的运用和父进程与子进程间的同步。实验内容包括使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值