Windows API 进程间通信，管道(Pipe)

转载自：Windows API 进程间通信，管道(Pipe)

管道是一种用于在进程间共享数据的机制，其实质是一段共享内存。Windows系统为这段共享的内存设计采用数据流I/0的方式来访问。由一个进程读、另一个进程写，类似于一个管道两端，因此这种进程间的通信方式称作“管道”。

管道分为匿名管道和命名管道。

匿名管道只能在父子进程间进行通信，不能在网络间通信，而且数据传输是单向的，只能一端写，另一端读。

命令管道可以在任意进程间通信，通信是双向的，任意一端都可读可写，但是在同一时间只能有一端读、一端写。

一、注意点

1、常用API

Pipes[2]

在[3,4]中也对这一部分进行了介绍。

2、示例

1）服务器端

创建管道 >> 监听 >> 读写 >> 关闭

CreateNamedPipe

ConnectNamedPipe

ReadFile/WriteFile

DisconnectNamedPipe

示例代码

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

/*
头文件
*/
#include
<
windows.h
>
#include
<
stdio.h
>
#include
<
tchar.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;
/*
************************************ * int main(VOID) * 功能 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;
//
读和写，注意CompletedWriteRoutine和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
; }
/*
************************************ * CompletedWriteRoutine * 写入pipe操作的完成函数 * 接口参见FileIOCompletionRoutine回调函数定义 * * 当写操作完成时被调用，开始读另外一个客户端的请求 *************************************
*/
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,
//
写读操作完成后，调用CompletedReadRoutine

(LPOVERLAPPED_COMPLETION_ROUTINE) CompletedReadRoutine); }
if
(
!
fRead)
//
出错，断开连接

DisconnectAndClose(lpPipeInst); }
/*
************************************ * CompletedReadRoutine * 读取pipe操作的完成函数 * 接口参见FileIOCompletionRoutine回调函数定义 * * 当读操作完成时被调用，写入回复 *************************************
*/
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,
//
将响应写入pipe

lpPipeInst
->
cbToWrite, (LPOVERLAPPED) lpPipeInst,
//
写入完成后，调用CompletedWriteRoutine

(LPOVERLAPPED_COMPLETION_ROUTINE) CompletedWriteRoutine); }
if
(
!
fWrite)
//
出错，断开连接

DisconnectAndClose(lpPipeInst); }
/*
************************************ * VOID DisconnectAndClose(LPPIPEINST lpPipeInst) * 功能 断开一个连接的实例 * 参数 lpPipeInst，断开并关闭的实例句柄 *************************************
*/
VOID DisconnectAndClose(LPPIPEINST lpPipeInst) {
//
关闭连接实例

if
(
!
DisconnectNamedPipe(lpPipeInst
->
hPipeInst) ) { printf(
"
DisconnectNamedPipe failed with %d.\n
"
, GetLastError()); }
//
关闭 pipe 实例的句柄

CloseHandle(lpPipeInst
->
hPipeInst);
//
释放

if
(lpPipeInst
!=
NULL) HeapFree(GetProcessHeap(),
0
, lpPipeInst); }
/*
************************************ * BOOL CreateAndConnectInstance(LPOVERLAPPED lpoOverlap) * 功能 建立连接实例 * 参数 lpoOverlap，用于overlapped IO的结构 * 返回值 是否成功 *************************************
*/
BOOL CreateAndConnectInstance(LPOVERLAPPED lpoOverlap) { LPTSTR lpszPipename
=
TEXT(
"
\\\\.\\pipe\\samplenamedpipe
"
);
//
创建named pipe

hPipe
=
CreateNamedPipe( lpszPipename,
//
pipe 名

PIPE_ACCESS_DUPLEX
|
//
可读可写

FILE_FLAG_OVERLAPPED,
//
overlapped 模式
//
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) * 功能 建立连接实例 * 参数 lpoOverlap，用于overlapped IO的结构 * 返回值 是否成功 *************************************
*/
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(
"
ConnectNamedPipe failed with %d.\n
"
, GetLastError());
return
0
; } }
return
fPendingIO; }
//
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); }

2）客户端

打开命令管道，获得句柄 >> 写入数据 >> 等待回复

WaitNamedPipe

SetNamedPipeHandleState

示例代码

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

/*
头文件
*/
#include
<
windows.h
>
#include
<
stdio.h
>
#include
<
conio.h
>
#include
<
tchar.h
>

/*
常量
*/

#define
BUFSIZE 512

/*
************************************ * int main(VOID) * 功能 pipe 通信服务端主函数 *************************************
*/

int
main(
int
argc, TCHAR
*
argv[]) { HANDLE hPipe; LPTSTR lpvMessage
=
TEXT(
"
Default message from client
"
); TCHAR chBuf[BUFSIZE]; BOOL fSuccess; DWORD cbRead, cbWritten, dwMode; LPTSTR lpszPipename
=
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实例都处于繁忙状态，等待2秒。

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(
"
SetNamedPipeHandleState 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);
//
ERROR_MORE_DATA 或者成功则循环

getch();
//
任意键退出
//
关闭句柄

CloseHandle(hPipe);
return
0
; }

3、I/O简介

I/O模式不仅在进程间通信时使用，任何具有数据流形式的输入输出（包括文件输入输出、内核通信、网络输入输出等）都涉及I/O模式。

异步( Asynchronous)和同步(Synchronous) I/O是两种基本的I/O模式。

同步I/O

所谓同步I/O是指在调用ReadFile、WriteFile等函数进行输入输出操作时，系统完成了输入输出ReadFile、WriteFile才返回。在操作系统进行I/O操作的过程上，用户态线程不能执行，因此在同步I/O时，如果需要在I/O时进行其他操作就只能再开启线程。

异步I/O

异步I/O是在调用ReadFile、WriteFile等函数后，函数立即返回，线程可以进行其他操作。剩下的I/O操作在系统内核中自动完成。那么在系统内核完成输入输出后，程序如何知道I/O是否已完成？

一种方法，称作完成函数（Completion Routines），如果使用ReadFileEx、WriteFileEx等进行I/O，可以指定完成函数，所谓完成函数是指内核在完成I/O后，内核会回调这个函数。当完成函数被调用时，就指明内核已经完成了I/O，程序可以在这个函数中进行一个I/O完成后需要的操作（例如释放内存）。

参考

[1] 精通Windows API 函数、接口、编程实例

[2] http://msdn.microsoft.com/en-us/library/aa365137%28VS.85%29.aspx
[3] http://www.cnblogs.com/mydomain/archive/2010/09/18/1830452.html

[4] http://www.cnblogs.com/mydomain/archive/2010/09/04/1818266.html