【并发编程三】C++实现通信——管道（pipe）
一、管道（pipe）
所谓的管道，就是内核⾥⾯的⼀串缓存（Pipe）。一个进程从管道的⼀端写⼊的数据，实际上是缓存在内核中的，另⼀端读取，也就是从内核中读取这段数据。
- 有两种类型的管道：匿名管道，有名管道（也叫命名管道）
二、匿名管道
1、简介
匿名管道只能用于父子进程间通信 ，不能跨网络通信，并且通信是单向。另外，管道传输的数据是⽆格式的流且⼤⼩受限。
正常情况下，控制台进程的输输入出是在控制台窗口的，但是如果我们在创建子进程的时候指定了其输入输出，那么子进程就会从我们的管道读数据，把输出数据写到我们指定的管道。
这就是我们代码中重定向标准输入的原因，否则system(“pause”）会无效。
2、父子进程：匿名管道的通信过程？
父进程写管道、子进程读管道，过程如下。
- 1、父进程，CreatePipe()创建管道会得到两个句柄，即，管道的读句柄和管道的写句柄。
- 2、父进程执行CreateProcess()启动子进程时，可以把句柄传（比如把读句柄传给子进程）递给子进程，写句柄父进程自己保存。
- 3、父进程调用调用WriteFile（）将数据写入到管道。
- 4、子进程调用GetStdHandle（）取得管道的读句柄，
- 5、然后，子进程ReadFile（）从管道读取出数据。
这样就做到了两个进程各有一个句柄（父进程写句柄、子进程读句柄），两个进程就可以通过各⾃的句柄 写⼊和读取同⼀个管道⽂件实现跨进程通信。
- 以上流程说的是父进程写管道，子进程读管道。当然，也可以反过来，子进程写、父进程读，那就是父进程把写句柄给子进程，父进程保存读句柄）
3、相关函数
3.1、创建管道CreatePipe
BOOL CreatePipe(
PHANDLE hReadPipe; //指向管道读句柄
PHANDLE hWritePipe; //指向管道写句柄
LPSECURITY_ATTRIBUTES lpPipeAttributes; //指向管道安全属性
DWORD nSize; //管道大小
)- linux系统下对应的创建匿名管道的函数是
3.2、写入管道WriteFile
BOOL WriteFile(
HANDLE hFile,//文件句柄
LPCVOID lpBuffer,//数据缓存区指针
DWORD nNumberOfBytesToWrite,//要写的字节数
LPDWORD lpNumberOfBytesWritten,//用于保存实际写入字节数的存储区域的指针
LPOVERLAPPED lpOverlapped//OVERLAPPED结构体指针
);3.3、读取管道ReadFile
BOOL ReadFile(
HANDLE hFile, //文件的句柄
LPVOID lpBuffer, //接收数据的缓冲区
DWORD nNumberOfBytesToRead, //读取的字节数
LPDWORD lpNumberOfBytesRead, //指向实际读取字节数的指针
LPOVERLAPPED lpOverlapped
//如文件打开时指定了FILE_FLAG_OVERLAPPED，那么必须，用这个参数引用一个特殊的结构。
//该结构定义了一次异步读取操作。否则，应将这个参数设为NULL
);3.4、获取句柄GetStdHandle
该函数用于取得指定的标准设备的句柄（标准输入，标准输出或标准错误），本文demo用于：子进程获取父进程传递的读句柄。
HANDLE WINAPI GetStdHandle( _In_ DWORD nStdHandle);GetStdHandle函数的参数可以是下列之一
| 参数 | 含义 |
|---|---|
| STD_INPUT_HANDLE | 标准输入句柄 |
| STD_OUTPUT_HANDLE | 标准输出句柄 |
| STD_ERROR_HANDLE | 标准错误句柄 |
4、demo
- 父进程
//main.cpp
#include <windows.h>
#include "iostream"
#define BUFSIZE 4096
using namespace std;
int main(int argc, char* argv[])
{
cout << "\n ** This is a message from the father process. ** \n";
cout << "第一步：创建管道" << endl;
// Set the bInheritHandle flag so pipe handles are inherited.
SECURITY_ATTRIBUTES saAttr;
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;
// Create a pipe for the child process's STDIN.
HANDLE handle_read;
HANDLE handle_write;
bool ret = CreatePipe(&handle_read, &handle_write, &saAttr, 0);
if (!ret)
{
cout << "创建进程失败：create pipe fail" << endl;
}
//设置写句柄不可以被子进程继承,不设置也不影响。 Ensure the write handle to the pipe for STDIN is not inherited.
if (!SetHandleInformation(handle_write, HANDLE_FLAG_INHERIT, 0))
{
cout << "设置句柄失败：set handle fail!" << endl;
}
cout << "第一步：子进程、设置管道句柄的继承" << endl;
{
// Create the child process.
char cmdline[] = "childprocess.exe";
PROCESS_INFORMATION piProcInfo;
// Set up members of the PROCESS_INFORMATION structure.
ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));
// Set up members of the STARTUPINFO structure. // This structure specifies the STDIN handles for redirection.
STARTUPINFO si;
ZeroMemory(&si, sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.hStdInput = handle_read; //把管道的读句柄传给子进程
si.dwFlags |= STARTF_USESTDHANDLES;
// Create the child process.
ret = CreateProcess(NULL, cmdline, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &piProcInfo);
if (!ret)
cout << "创建子进程失败：create child process faile!";
else
{
cout << "创建子进程成功：create child process sucess!";
// Close handles to the child process and its primary thread.
CloseHandle(piProcInfo.hProcess);
CloseHandle(piProcInfo.hThread);
CloseHandle(handle_read);
}
}
cout << "第三步：向管道中写入数据：write to pipe." << endl;
{
// write contents to the pipe for the child's STDIN.
DWORD len;
char chBuf[BUFSIZE] = " hello pipe";
for (int i = 0; i < 10; i++)
{
bool ret = WriteFile(handle_write, chBuf, sizeof(chBuf), &len, NULL);//子进程读了后，父进程才可以继续写入管道
if (!ret)
{
cout << "写入管道数据失败。i=" << i << endl;
break;
}
else
{
cout << "send data " << i << " is:" << chBuf << endl;
}
}
cout << "写入管道数据结束。" << endl;
// Close the pipe handle so the child process stops reading.
if (!CloseHandle(handle_write))
cout << "colse handle fail" << endl;
}
return 0;
}
#CmakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 3.8.0)
PROJECT(process)
ADD_EXECUTABLE(process main.cpp)
ADD_SUBDIRECTORY(childprocess)
SET(EXECUTABLE_OUTPUT_PATH "${PROJECT_SOURCE_DIR}/lib")- 子进程
// main.cpp
#include <windows.h>
#include"iostream"
#define BUFSIZE 4096
using namespace std;
int main(int argc, char* argv[])
{
cout<<"\n ** This is a message from the child process. ** \n";
CHAR chBuf[BUFSIZE];
DWORD len;
HANDLE handle_read;
handle_read = GetStdHandle(STD_INPUT_HANDLE);
if (handle_read == INVALID_HANDLE_VALUE)
ExitProcess(1);
for (int i = 0;i<5;i++)
{
// Read from standard input and stop on error or no data.
bool ret = ReadFile(handle_read, chBuf, BUFSIZE, &len, NULL);
if (!ret || len == 0)
{
cout << "读取数据失败" << endl;
break;
}
cout << "receive data "<<i<<" is:" << chBuf << endl;
}
cout << "读取数据结束" << endl;
Sleep(5000);
freopen("CON", "r", stdin); // 重定向输入,否则system("pause")会无效
//CloseHandle(handle_read);
system("pause");
return 0;
}
#CmakeLists.txt
CMAKE_MINIMUM_REQUIRED(VERSION 3.8.0)
SET(TARGET "childprocess")
ADD_EXECUTABLE(childprocess main.cpp)
SET(LIBRARY_OUTPUT_PATH "${PROJECT_SOURCE_DIR}/lib")
SET(EXECUTABLE_OUTPUT_PATH "${PROJECT_SOURCE_DIR}/lib")
5、结果
- 父进程
- 子进程
- 后记
1.子进程取出管道中的数据后，父进程才可以继续往管道中写入数据
2.父进程在输入第5个send data后，子进程并没有读取。但是当子的sleep结束后，不知什么原因，不确定第5次的输入是被谁读走的。
3.子进程的sleep函数之前的输出如下
三、有名管道
1、简介
命名管道，顾名思义，这个管道肯定是有名字的。通过管道的名字来确保多个进程访问同一个管道。事实上，命名管道不仅可在同一台计算机的不同进程之间传输数据，甚至能在跨越一个网络的不同计算机的不同进程之间，支持可靠的、单向或双向的数据通信。
命名管道的服务器和客户机的区别在于：
服务器是唯一一个有权创建命名管道的进程，也只有他才能接受管道客户机的连接请求。
而客户机只能同一个线程的命名管道服务器建立连接。
- 命名管道具有很好的使用灵活性，表现在：
1) 既可用于本地，又可用于网络。
2) 可以通过它的名称而被引用。
3) 支持多客户机连接。
4) 支持双向通信。
5)支持异步重叠I/O操作
2、两个进程间：命名管道的工作过程
- 3.2 服务器
命名管道服务器,步骤如下：
1）使用API函数CreateNamedPipe，创建一个命名管道实例句柄。
2）使用API函数ConnectNamedPipe，在命名管道实例上监听客户机连接请求。
3）分别使用ReadFile和WriteFile这两个API函数，从客户机接收数据，或将数据发给客户机。
4）使用API函数DisconnectNamedPipe，关闭命名管道连接。
5）使用API函数CloseHandle，关闭命名管道实例句柄。 - 3.2 客户端
命名管道客户机,步骤如下：
1）调用API函数WaitNamedPipe，等候一个命名管道实例可供使用。
2）调用API函数CreateFile，打开命名管道实例并建立连接。
3）调用API函数WriteFile和ReadFile，分别向服务器发送数据和从中接收数据。
4）调用API函数CloseHandle，关闭打开的命名管道会话。
3、相关函数
3.1、创建命名管道CreateNamedPipe
创建命名管道的实例，并返回后续管道操作的句柄。
HANDLE CreateNamedPipeA(
[in] LPCSTR lpName,
[in] DWORD dwOpenMode,
[in] DWORD dwPipeMode,
[in] DWORD nMaxInstances,
[in] DWORD nOutBufferSize,
[in] DWORD nInBufferSize,
[in] DWORD nDefaultTimeOut,
[in, optional] LPSECURITY_ATTRIBUTES lpSecurityAttributes
);
CreateNamedPipe函数接口中的第一个参数lpName: .\pipe\pipename， 必须为这种格式。中间的“.”表示本地机器，如果要跟远程机器建立连接，则需要设定远程服务器的名字。
详细解释请参考：CreateNamedPipeA 函数 (winbase.h)
3.2、监听请求ConnectNamedPipe
在命名管道实例上监听客户机连接请求。
BOOL ConnectNamedPipe(
[in] HANDLE hNamedPipe,
[in, out, optional] LPOVERLAPPED lpOverlapped
);详细解释请参考：ConnectNamedPipe 函数 (namedpipeapi.h)
3.3、等候一个命名管道实例WaitNamedPipe
等到超时间隔过或指定命名管道的实例可用于连接
BOOL ConnectNamedPipe(
[in] HANDLE hNamedPipe,
[in, out, optional] LPOVERLAPPED lpOverlapped
);详细解释请参考：WaitNamedPipeA 函数 (winbase.h)
4、demo
- 服务端
#include <iostream>
#include <windows.h>
using namespace std;
int main()
{
printf("创建命名管道并等待连接\n");
char pipeName[] = "\\\\.\\Pipe\\mypipe";
HANDLE hPipe = CreateNamedPipe(pipeName, PIPE_ACCESS_DUPLEX, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT
, PIPE_UNLIMITED_INSTANCES, 0, 0, NMPWAIT_WAIT_FOREVER, 0);
//waiting to be connected
if (ConnectNamedPipe(hPipe, NULL) != NULL)
{
printf("连接成功，开始发送数据\n");
DWORD dwWrite;
const char* pStr = "data from server";
if (!WriteFile(hPipe, pStr, strlen(pStr), &dwWrite, NULL))
{
cout << "write failed..." << endl << endl;
return 0;
}
cout << "sent data: " << endl << pStr << endl << endl;
}
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);//关闭管道
printf("关闭管道\n");
system("pause");
}- 客户端
// ClientPip.cpp
#include <iostream>
#include <windows.h>
using namespace std;
#define BUFSIZE 5
int main()
{
printf("命名管道:客户端上线\n");
printf("按任意键以开始连接命名管道\n");
getchar();
printf("开始等待命名管道\n");
char pipeName[] = "\\\\.\\Pipe\\mypipe";
if (WaitNamedPipe(pipeName, NMPWAIT_WAIT_FOREVER) == FALSE)
return 0;
printf("打开命名管道\n");
HANDLE hPipe = CreateFile(pipeName, GENERIC_READ | GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if ((long)hPipe == -1)
return 0;
//接收服务端发回的数据
BOOL fSuccess = false;
DWORD len = 0;
char buffer[BUFSIZE];
string recvData = "";
do
{
fSuccess = ReadFile(hPipe, buffer, BUFSIZE * sizeof(char), &len, NULL);
char buffer2[BUFSIZE + 1] = { 0 };
memcpy(buffer2, buffer, len);
recvData.append(buffer2);
if (!fSuccess || len < BUFSIZE)
break;
} while (true);
cout << "recv data:" << endl << recvData.c_str() << endl << endl;
FlushFileBuffers(hPipe);
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);
system("pause");
return 0;
}5、输出
参考：
1、C++的创建命名管道（CreateNamedPipe）
2、C++实现进程通信（管道pipe）