pipe我们用中文叫做管道。

以下讲解均是基于Linux为环境:

所需头文件 #include<unistd.h>

函数原型 int pipe(int fd[2])

函数传入值 fd[2]:管道的两个文件描述符，之后就是可以直接操作这两个文件描述符

返回值 成功 0 失败 -1

管道是Linux 支持的最初Unix IPC形式之一，具有以下特点:

管道是半双工的，数据只能向一个方向流动;需要双方通信时，需要建立起两个管道; 只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程); 单独构成一种独立的文件系统:管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在于内存中。数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。

#include <unistd.h>

int pipe(int fd[2])

该函数创建的管道的两端处于一个进程中间，在实际应用中没有太大意义，因此，一个进程在由pipe()创建管道后，一般再fork一个子进程，然后通过管道实现父子进程间的通信(因此也不难推出，只要两个进程中存在亲缘关系，这里的亲缘关系指的是具有共同的祖先，都可以采用管道方式来进行通信)。

管道两端可分别用描述字fd[0]以及fd[1]来描述，需要注意的是，管道的两端是固定了任务的。即一端只能用于读，由描述字fd[0]表示，称其为管道读端;另一端则只能用于写，由描述字fd[1]来表示，称其为管道写端。如果试图从管道写端读取数据，或者向管道读端写入数据都将导致错误发生。一般文件的I/O函数都可以用于管道，如close、read、write等等。

如果管道的读端不存在，则认为已经读到了数据的末尾，读函数返回的读出字节数为0; 当管道的读端存在时，如果请求的字节数目大于PIPE_BUF，则返回管道中现有的数据字节数，如果请求的字节数目不大于PIPE_BUF，则返回管道中现有数据字节数(此时，管道中数据量小于请求的数据量);或者返回请求的字节数(此时，管道中数据量不小于请求的数据量)。注:(PIPE_BUF在include/linux/limits.h中定义，不同的内核版本可能会有所不同。Posix.1要求PIPE_BUF至少为512字节，red hat 7.2中为4096)。

关于管道的读规则验证:

/**************

* readtest.c *

**************/

#include <unistd.h>

#include <sys/types.h>

#include <errno.h>

main()

{

int pipe_fd[2];

pid_t pid;

char r_buf[100];

char w_buf[4];

char* p_wbuf;

int r_num;

int cmd;

memset(r_buf,0,sizeof(r_buf));

memset(w_buf,0,sizeof(w_buf));

p_wbuf=w_buf;

if(pipe(pipe_fd)<0)

{

printf("pipe create error ");

return -1;

}

if((pid=fork())==0)

{

printf(" ");

close(pipe_fd[1]);

sleep⑶;//确保子进程关闭写端

r_num=read(pipe_fd[0],r_buf,100);

printf("read num is %d the data read from the pipe is %d ",r_num,atoi(r_buf));

close(pipe_fd[0]);

exit();

}

else if(pid>0)

{

close(pipe_fd[0]);//read

strcpy(w_buf,"111");

if(write(pipe_fd[1],w_buf,4)!=-1)

printf("parent write over ");

close(pipe_fd[1]);//write

printf("parent close fd[1] over ");

sleep⑽;

}

}

/**************************************************

* 程序输出结果:

* parent write over

* parent close fd[1] over

* read num is 4 the data read from the pipe is 111

* 附加结论:

* 管道写端关闭后，写入的数据将一直存在，直到读出为止.

****************************************************/

向管道中写入数据:

向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞。

对于没有设置阻塞标志的写操作:(1)当要写入的数据量不大于PIPE_BUF时，Linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回;如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写。(2)当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。

注:只有在管道的读端存在时，向管道中写入数据才有意义。否则，向管道中写入数据的进程将收到内核传来的SIGPIPE信号，应用程序可以处理该信号，也可以忽略(默认动作则是应用程序终止)。

对管道的写规则的验证1:写端对读端存在的依赖性

#include <unistd.h>

#include <sys/types.h>

main()

{

int pipe_fd[2];

pid_t pid;

char r_buf[4];

char* w_buf;

int writenum;

int cmd;

memset(r_buf,0,sizeof(r_buf));

if(pipe(pipe_fd)<0)

{

printf("pipe create error ");

return -1;

}

if((pid=fork())==0)

{

close(pipe_fd[0]);

close(pipe_fd[1]);

sleep⑽;

exit();

}

else if(pid>0)

{

sleep⑴; //等待子进程完成关闭读端的操作

close(pipe_fd[0]);//write

w_buf="111";

if((writenum=write(pipe_fd[1],w_buf,4))==-1)

printf("write to pipe error ");

else

printf("the bytes write to pipe is %d ",writenum);

close(pipe_fd[1]);

}

}

则输出结果为:Broken pipe，原因就是该管道以及它的所有fork()产物的读端都已经被关闭。如果在父进程中保留读端，即在写完pipe后，再关闭父进程的读端，也会正常写入pipe，读者可自己验证一下该结论。因此，在向管道写入数据时，至少应该存在某一个进程，其中管道读端没有被关闭，否则就会出现上述错误(管道断裂，进程收到了SIGPIPE信号，默认动作是进程终止)

对管道的写规则的验证2:linux不保证写管道的原子性验证

#include <unistd.h>

#include <sys/types.h>

#include <errno.h>

main(int argc,char**argv)

{

int pipe_fd[2];

pid_t pid;

char r_buf[4096];

char w_buf[4096*2];

int writenum;

int rnum;

memset(r_buf,0,sizeof(r_buf));

if(pipe(pipe_fd)<0)

{

printf("pipe create error ");

return -1;

}

if((pid=fork())==0)

{

close(pipe_fd[1]);

while⑴

{

sleep⑴;

rnum=read(pipe_fd[0],r_buf,1000);

printf("child: readnum is %d ",rnum);

}

close(pipe_fd[0]);

exit();

}

else if(pid>0)

{

close(pipe_fd[0]);//write

memset(r_buf,0,sizeof(r_buf));

if((writenum=write(pipe_fd[1],w_buf,1024))==-1)

printf("write to pipe error ");

else

printf("the bytes write to pipe is %d ",writenum);

writenum=write(pipe_fd[1],w_buf,4096);

close(pipe_fd[1]);

}

}

输出结果:

the bytes write to pipe is 1000

the bytes write to pipe 4096

child: readnum is 1000 //注意，此行输出说明了写入的非原子性

child: readnum is pipe 1000

child: readnum is pipe 1000

child: readnum is pipe 1000

child: readnum is pipe 1000

child: readnum is pipe 120 //注意，此行输出说明了写入的非原子性

child: readnum is pipe 0

child: readnum is pipe 0

......

结论:

写入数目小于4096时写入是非原子的!

如果把父进程中的两次写入字节数都改为5000，则很容易得出下面结论:

写入管道的数据量大于4096字节时，缓冲区的空闲空间将被写入数据(补齐)，直到写完所有数据为止，如果没有进程读数据，则一直阻塞。

实例一:用于shell

管道可用于输入输出重定向，它将一个命令的输出直接定向到另一个命令的输入。比如，当在某个shell程序(Bourne shell或C shell等)键入who│wc -l后，相应shell程序将创建who以及wc两个进程和这两个进程间的管道。考虑下面的命令行:

$kill -l 运行结果见附一。

$kill -l | grep SIGRTMIN 运行结果如下:

30) SIGPWR 31) SIGSYS 32) SIGRTMIN 33) SIGRTMIN+1

34) SIGRTMIN+2 35) SIGRTMIN+3 36) SIGRTMIN+4 37) SIGRTMIN+5

38) SIGRTMIN+6 39) SIGRTMIN+7 40) SIGRTMIN+8 41) SIGRTMIN+9

42) SIGRTMIN+10 43) SIGRTMIN+11 44) SIGRTMIN+12 45) SIGRTMIN+13

46) SIGRTMIN+14 47) SIGRTMIN+15 48) SIGRTMAX-15 49) SIGRTMAX-14

实例二:用于具有亲缘关系的进程间通信

下面例子给出了管道的具体应用，父进程通过管道发送一些命令给子进程，子进程解析命令，并根据命令作相应处理。

#include <unistd.h>

#include <sys/types.h>

main()

{

int pipe_fd[2];

pid_t pid;

char r_buf[4];

char* w_buf[256];

int childexit=0;

int i;

int cmd;

memset(r_buf,0,sizeof(r_buf));

if(pipe(pipe_fd)<0)

{

printf("pipe create error ");

return -1;

}

if((pid=fork())==0)

//子进程:解析从管道中获取的命令，并作相应的处理

{

printf(" ");

close(pipe_fd[1]);

sleep⑵;

while(!childexit)

{

read(pipe_fd[0],r_buf,4);

cmd=atoi(r_buf);

if(cmd==0)

{

printf("child: receive command from parent over now child process exit ");

childexit=1;

}

else if(handle_cmd(cmd)!=0)

return;

sleep⑴;

}

close(pipe_fd[0]);

exit();

}

else if(pid>0)

//parent: send commands to child

{

close(pipe_fd[0]);

w_buf[0]="003";

w_buf[1]="005";

w_buf[2]="777";

w_buf[3]="000";

for(i=0;i<4;i++)

write(pipe_fd[1],w_buf[i],4);

close(pipe_fd[1]);

}

}

//下面是子进程的命令处理函数(特定于应用):

int handle_cmd(int cmd)

{

if((cmd<0)||(cmd>256))

//suppose child only support 256 commands

{

printf("child: invalid command ");

return -1;

}

printf("child: the cmd from parent is %d ",cmd);

return 0;

}

PIPENET系列产品包括标准模块、消防模块以及瞬态模块，其中每个模块都是独立运行的软件。

PIPENET管网流体分析软件起源于七十年代的剑桥大学。1979年，剑桥大学计算机中心将其收购并命名为PIPENET，1985年SUNRISE SYSTEMS LIMITED公司成立，独立进行PIPENET软件的研发和拓展。PIPENET系列软件具有广泛的工业用途，具备强大的工程管网系统的数值计算、模拟仿真和系统优化等功能。能够使工程管网系统的设计更科学、更合理、更经济、更安全;同时有效地提高设计效率、增加工程收益、降低事故发生率。

PIPENET系列产品包括标准模块、消防模块以及瞬态模块，其中每个模块都是独立运行的软件。

PIPENET标准模块用于工业管网稳态设计的数值计算及模拟仿真。其具体功能包括:管径选型;泵、阀、孔板等设备选型;流场计算(系统各部件的压力、压损、流量、流速等);异常工况(堵、漏等)的模拟;系统圆整优化;便捷的数据读入和输出等。

PIPENET消防模块用于消防管网稳态设计的数值计算及模拟仿真，遵循国际公认和常用的各种消防规范(如NFPA美国消防规范、FOC英联邦国家消防规范、GB国标消防规范等)，并符合上述规范对各行业消防系统设计的严格而特殊的各种强制性计算和布置要求，同时生成国际通用的NFPA格式的消防计算书。

PIPENET瞬态模块又分为普通管网的瞬态模块和消防管网的瞬态模块，分别用于工业管网和消防管网的动态分析、模拟仿真和数值计算。其具体功能包括:水锤(汽锤)分析、管道振动分析、动态力的数值计算、泵阀的启停设计、控制系统的动态响应模拟、关键设备(安全阀、蓄能器、真空破坏阀、箱体等等)的选型和动态响应模拟等等，并提供数值计算报告、动态力的计算数值输出、波形图的输出、编辑、比对等功能。

与其他同类软件相比，PIPENET软件有以下的特点:

PIPENET软件是面向工程设计单位研发设计的专业工程管网计算分析软件，具体表现为:在软件的界面视图、内置模型、软件功能的设计、各种边界条件所需参数、计算结果的输出等等各方面均结合了工程设计的特点和需求。

PIPENET软件通过了二、三十年的不断拓展更新，具备了界面友好简捷、软件功能强大、所需参数便于获得、易学易用等显著的特点。

PIPENET模型采用类似工艺流程图的示意性模型，并采用集中参数法。将弯头、三通、闸阀、蝶阀等没有操作动作的管道元件或装置作为管道的阻力参数输入，需要做修改时，只需修改参数，而无需修改模型，大幅提高设计效率。

PIPENET软件以计算和模拟复杂管网著称，可以计算和模拟各种复杂的管网系统以及环网系统，其计算功能不受环网的个数和复杂程度的限制。

目前PIPENET消防模块是国际工程界独一无二的消防水力计算软件，与市场上流通的其他水力计算软件(包括PIPENET标准模块 )相比，PIPENET消防模块使用消防规范特殊的阻力计算公式，并满足消防系统设计的专业算法与布置要求，而且将计算报告生成专业格式(NFPA格式)的消防计算书。

动态力是由水锤(汽锤)现象导致的沿管向游窜的瞬间不平衡力，通常称为水锤力(汽锤力)，该力的瞬间动量非常大，足以破坏管道系统或结构。PIPENET可计算动态力并生成时间与力的计算结果，并将结果生成.FRC文档，传递给管道应力分析软件，做结构分析及阻尼器的设计。

PIPENET瞬态模块有TURBO PUMP模型，不仅可以模拟泵的正常工况，还可以模拟泵启动和停泵倒转的全工况。

由于TURBO PUMP模型需要SUTER CURVE等不易获取的参数信息，PIPENET瞬态模块研发了独有的INERTIAL PUMP模型，可以利用厂家所能提供的参数信息，模拟启泵和停泵的工况。

PIPENET瞬态模块可以为安全阀、呼吸阀、压力容器等在动态工况下工作的关键设备进行动态设备选型，使设备的型号更准确、更安全、更经济。

PIPENET瞬态模块可模拟工程中常用的各种控制系统，以及控制系统在整个管网系统中的动态响应，可将大量的予调试工作在设计阶段完成，缩短工程建造的调试周期。

PIPENET软件与PDS /PDMS软件有接口，通过接口，可直接将管路的三维模型读成PIPENET模型，添加上所需的边界条件就可进行计算。拓展了PIPENET软件的应用范围。

PIPENET软件与Caesar II软件有接口，可将PIPENET动态力的计算结果传递给结构分析软件进行支吊架的设计以及阻尼器的设计。

CreateNamedPipe

VB声明

Declare Function CreateNamedPipe Lib "kernel32" Alias "CreateNamedPipeA" (ByVal lpName As String, ByVal dwOpenMode As Long, ByVal dwPipeMode As Long, ByVal nMaxInstances As Long, ByVal nOutBufferSize As Long, ByVal nInBufferSize As Long, ByVal nDefaultTimeOut As Long, lpSecurityAttributes As SECURITY_ATTRIBUTES) As Long

说明

创建一个命名管道。返回的句柄由管道的服务器端使用

返回值

Long，如执行成功，返回管道的句柄。INVALID_HANDLE_VALUE表示失败。会设置GetLastError

参数表

参数 类型及说明

lpName String，指定管道名，采用的形式是:\\.\管道\管道名。最多可达256个字符的长度，而且不用区分大小写。如果存在指定名字的一个管道，则创建那个管道的一个新实例

dwOpenMode Long，下述常数组的一个组合

下述常数之一(对于管道的所有实例都要一样):

PIPE_ACCESS_DUPLEX 管道是双向的

PIPE_ACCESS_INBOUND 数据从客户端流到服务器端

PIPE_ACCESS_OUTBOUND 数据从服务器端流到客户端

下述常数的任意组合

FILE_FLAG_WRITE_THROUGH 在网络中建立的字节型管道内，强迫数据在每次读写操作的时候通过网络传输。否则传输就可能延迟

FILE_FLAG_OVERLAPPED 允许(但不要求)用这个管道进行异步(重叠式)操作

常数WRITE_DAC， WRITE_OWNER 和 ACCESS_ SYSTEM_SECURITY提供了附加的安全选项

dwPipeMode Long，下述常数组的一个组合:

下述常数之一(管道的所有实例都必须指定相同的常数)

PIPE_TYPE_BYTE 数据作为一个连续的字节数据流写入管道

PIPE_TYPE_MESSAGE 数据用数据块(名为"消息"或"报文")的形式写入管道

下述常数之一:

PIPE_READMODE_BYTE 数据以单独字节的形式从管道中读出

PIPE_READMODE_MESSAGE 数据以名为"消息"的数据块形式从管道中读出(要求指定PIPE_TYPE_MESSAGE)

下述常数之一:

PIPE_WAIT 同步操作在等待的时候挂起线程

PIPE_NOWAIT(不推荐!) 同步操作立即返回。这样可为异步传输提供一种落后的实现方法，已由Win32的重叠式传输机制取代了

nMaxInstances Long，这个管道能够创建的最大实例数量。必须是1到常数PIPE_UNLIMITED_INSTANCES间的一个值。它对于管道的所有实例来说都应是相同的

nOutBufferSize Long，建议的输出缓冲区长度;零表示用默认设置

nInBufferSize Long，建议的输入缓冲区长度;零表示用默认设置

nDefaultTimeOut Long，管道的默认等待超时。对一个管道的所有实例来说都应相同

lpSecurityAttributes SECURITY_ATTRIBUTES，指定一个SECURITY_ATTRIBUTES结构，或者传递零值(将参数声明为ByVal As Long，并传递零值)，以便使用不允许继承的一个默认描述符