Linux应用程序开发详解第8章
进程间通信_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
文档贡献者贡献于
评价文档：
9页免费65页免费22页免费85页1下载券85页免费55页免费3页免费11页免费41页免费35页免费
喜欢此文档的还喜欢9页免费42页1下载券31页1下载券16页免费45页1下载券
Linux应用程序开发详解第8章
进程间通信|L​i​n​u​x​应​用​程​序​开​发​详​解
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
大小：871.00KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢pipe_百度百科
关闭特色百科用户权威合作手机百科
收藏 查看&pipe
PIPE是，或者其他的以的一定购买股份以扩大的一种投资方式。PIPE主要分为传统型和结构型两种形式。传统的PIPE由发行人以设定价格向PIPE投资人发行优先或普通股来扩大资本。而结构性PIPE则是发行可转债（转换股份可以是普通股也可以是优先股）。外文名Private Investment in Public Equity类&&&&型投资方式主要形式传统型和结构型
这种融资方式非常受欢迎，相对于二次发行等传统的融资手段，PIPE的融资成本和融资效率要相对高一些。在PIPE发行中监管机构的审查更少一些，而且也不需要昂贵的路演，这使得获得资本的成本和时间都大大降低。PIPE比较适合一些快速成长为中型企业的上市公司，他们没有时间和精力应付传统股权融资的复杂程序。2007年至2011年，中国私募股权投资市场PIPE(私人股权投资已上市公司股份)投资案例数量呈现明显增长态势，案例数量由53起增加到143起，累计增幅达170%。从其在整个PE投资中占比来看，案例数量占比由2007年的15%增至2011年的37%。
从投资规模来看，2007年至今PIPE类型投资规模基本呈现平稳增长，披露规模由亿美元增至亿美元，增幅达23%。其中2008年因全球金融危机影响，投资规模略有下降，2009年因淡马锡联合厚朴投资73亿美元战略投资建设银行的巨额交易使得2009年PIPE投资规模居近6年之首。从PIPE投资在整个PE投资规模占比来看，扣除年的超低和超高影响，2010年至今基本维持在35%-45%的波动区间。
2012年至今PIPE投资案例数量按照行业分布来看，制造业、化学工业、金融、医疗健康四个行业分别以16、10、6、6起案例占比23%、16%、10%、10%居前四位;投资规模按照行业分布来看，金融行业、制造业、建筑建材行业分别以30.76亿美元、6.38亿美元、5.57亿美元占比49%、10%和9%位居各细分行业前三。[1]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]来表示，称其为管道写端。如果试图从管道写端读取数据，或者向管道读端写入数据都将导致错误发生。一般文件的函数都可以用于管道，如close、read、write等等。如果管道的写端不存在，则认为已经读到了数据的末尾，读函数返回的读出字节数为0； 当管道的写端存在时，如果请求的字节数目大于PIPE_BUF，则返回管道中现有的数据字节数，如果请求的字节数目不大于PIPE_BUF，则返回管道中现有数据字节数（此时，管道中数据量小于请求的数据量）；或者返回请求的字节数（此时，管道中数据量不小于请求的数据量）。注：（PIPE_BUF在include/linux/中定义，不同的可能会有所不同。Posix.1要求PIPE_BUF至少为512字节，red hat 7.2中为4096）。
关于管道的读规则验证：
/**************
* readtest.c *
**************/
#include &unistd.h&
#include &sys/types.h&
#include &errno.h&
int pipe_fd[2];
char r_buf[100];
char w_buf[4];
memset(r_buf,0,sizeof(r_buf));
memset(w_buf,0,sizeof(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]);
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 &);
/**************************************************
* 程序输出结果：
* 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空闲缓冲区后，写操作返回。
注：只有在管道的读端存在时，向管道中写入数据才有意义。否则，向管道中写入数据的进程将收到内核传来的SIFPIPE信号，可以处理该信号，也可以忽略（默认动作则是应用程序终止）。
对管道的写规则的验证1：写端对读端存在的依赖性
#include &unistd.h&
#include &sys/types.h&
int pipe_fd[2];
char r_buf[4];
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]);
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 &);
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];
char r_buf[4096];
char w_buf[4096*2];
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]);
rnum=read(pipe_fd[0],r_buf,1000);
printf(&child: readnum is %d &,rnum);
close(pipe_fd[0]);
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 &);
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&
int pipe_fd[2];
char r_buf[4];
char** w_buf[256];
int childexit=0;
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]);
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)
close(pipe_fd[0]);
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);
⒈管，导管，输送管[C]
They are laying pipes under the road.
他们正在铺设路下面的管子。
His father is a pipe-smoker.
他父亲是抽烟斗的。
⒊管乐器；笛[C]
He is playing a tune on his pipe.
他在用笛子吹奏一支曲子。
⒋笛声；鸟鸣声；尖锐的声音[U]
⒌管状器官；呼吸器官[C]
⒍（液量单位）最大桶[C]，大酒桶
⒎【口】容易干的事
⒈用管道输送[H][(+into/to)]
Water was piped into the village two years ago.
两年前水由管子通到了村里。
⒉（用尖声）说话，唱歌；尖声鸣叫
The woman piped her disapproval.
那妇人尖声嚷叫不赞成。
⒊用管乐器吹奏
I'll pipe your favorite song.
我来吹奏那支你喜欢听的歌。
⒋为...铺设管道
Our neighborhood will be piped for gas.
我们这个地区将要铺设煤气管。
⒌为（衣服）滚边；为（糕饼）浇饰花边
⒈吹奏管乐
⒉尖声叫嚷，尖声鸣叫
Wind was piping in the woods.
风在林中呼啸。
同义词 参见
名复： pipes
动变： piping管道的主要局限性体现在它的特点上：
只支持单向； 只能用于具有亲缘关系的进程之间； 没有名字； 管道的是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
管道所传送的是无格式，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；在Linux中，管道是一种使用非常频繁的通信机制。从本质上说，管道也是一种文件，但它又和一般的文件有所不同，管道可以克服使用文件进行通信的两个问题，具体表现为：
限制管道的大小。实际上，管道是一个固定大小的。在Linux中，该的大小为1页，即4K字节，使得它的大小不象文件那样不加检验地增长。使用单个固定也会带来问题，比如在写管道时可能变满，当这种情况发生时，随后对管道的write（）调用将默认地被阻塞，等待某些数据被读取，以便腾出足够的空间供write（）调用写。
读取进程也可能工作得比写进程快。当所有当前进程数据已被读取时，管道变空。当这种情况发生时，一个随后的read（）调用将默认地被阻塞，等待某些数据被写入，这解决了read（）调用返回文件结束的问题。
注意：从管道读数据是一次性操作，数据一旦被读，它就从管道中被抛弃，释放空间以便写更多的数据。在 Linux 中，管道的实现并没有使用专门的，而是借助了文件系统的file结构和VFS的inode。通过将两个 file 结构指向同一个临时的 VFS，而这个 VFS 索引节点又指向一个物理页面而实现的。如图 7.1所示。
图7.1 管道结构示意图
图7.1中有两个file，但它们操作例程地址是不同的，其中一个是向管道中写入数据的例程地址，而另一个是从管道中读出数据的例程地址。这样，的仍然是通常的文件操作，而却利用这种抽象机制实现了管道这一特殊操作。管道实现的在fs/pipe.c中，在pipe.c中有很多函数，其中有两个函数比较重要，即管道读函数pipe_read（）和管道写函数pipe_wrtie（）。管道写函数通过将字节复制到 VFS指向的而写入数据，而管道读函数则通过复制物理内存中的字节而读出数据。当然，必须利用一定的机制同步对管道的访问，为此，内核使用了锁、和信号。
当写进程向管道中写入时，它利用标准的库函数write（），系统根据库函数传递的，可找到该文件的 file 结构。file 结构中指定了用来进行写操作的函数（即写入函数）地址，于是，内核调用该函数完成写操作。写入函数在向内存中写入数据之前，必须首先检查 VFS中的信息，同时满足如下条件时，才能进行实际的内存复制工作：
内存中有足够的空间可容纳所有要写入的数据；
内存没有被读程序锁定。
如果同时满足上述条件，写入函数首先锁定内存，然后从写进程的中复制数据到内存。否则，写入进程就休眠在 VFS的中，接下来，内核将调用调度程序，而调度程序会选择其他进程运行。写入进程实际处于可中断的等待状态，当内存中有足够的空间可以容纳写入数据，或内存被解锁时，读取进程会唤醒写入进程，这时，写入进程将接收到信号。当数据写入内存之后，内存被解锁，而所有休眠在的读取进程会被唤醒。
管道的读取过程和写入过程类似。但是，进程可以在没有数据或内存被锁定时立即返回，而不是阻塞该进程，这依赖于文件或管道的打开模式。反之，进程可以休眠在的中等待写入进程写入数据。当所有的进程完成了之后，管道的被丢弃，而共享数据页也被释放。
因为管道的实现涉及很多文件的操作，因此，当读者学完有关文件系统的内容后来读pipe.c中的代码，你会觉得并不难理解。
新手上路我有疑问投诉建议参考资料 查看1241人阅读
一、Linux进程间通信方式 ：有六种方式在两个程序间传递信息
&&&&&&& 1、信号(&Singal )
&&&&&&& 2、管道 ( Pipe ) 及有名管道
&&&&&&&&3、信号量 ( Semaphore )
&&&&&&& 4、共享内存 ( SharedMessage)
&&&&&&&&5、消息队列 ( MessageQueue )
&&&&&&& 6、套接字& ( Socket )
& && 其中，共享内存是效率最高的。
二、具体介绍
&&&&&&& 1、信号(&Singal )&&&可以参考
& 中的信号通信部分
&&&&&&& 2、管道 ( Pipe ) 及有名管道
&&&&&&&&&&&&&&& 管道分为有名和无名管道。
&&&&&&&&&&&&& 无名管道用于父子进程间的通信。
&&&&& a、用pipe( )创建无名管道&&&&&&&
#include&stdio.h&
#include&stdlib.h&
#include&sys/types.h&
#include&memory.h&
#include&signal.h&
void my_func(int);
int main(){
int pfd[2];
char *msg=&pipe test program&;
char buf[100];
memset(buf,0,sizeof(buf));
//创建一个无名管道。一定要在fork之前创建。这样子进程才能有同样的一个管道
if(pipe(pfd)&0){
printf(&pipe create error!\n&);
if((pid = fork())&0){
printf(&fork error!\n&);
}else if(pid == 0){
//close(pfd[0]);
//此句是测试异常的时候使用
close(pfd[1]);
if(r=read(pfd[0],buf,100)&0){
printf(&read error!\n&);
waitpid(pid,NULL,0);
//等待子进程退出后再退出
printf(&child read from pipe: %s\n&,buf);
close(pfd[0]);
signal(SIGPIPE,my_func);
//当读端不存在时系统发出SIGPIPE信号
close(pfd[0]);
if(w=write(pfd[1],msg,strlen(msg))&0){
printf(&wirte error!\n&);
printf(&parent send msg to child!\n&);
close(pfd[1]);
waitpid(pid,NULL,0);
void my_func(int sig){
if(sig == SIGPIPE){
printf(&read not exist\n&);
&&& b、标准流管道： popen()&
&&&&&&&& 这个函数会完成：创建管道、fork()、关闭相应的文件描述符、执行exec、执行函数中指定的命令&&& 这一系列的操作。优点当然是省事啦，缺点必然是不灵活。popen( )返回的是文件指针所以要用标准IO操作。其中，第二个参数：&
r & 表示命令的输出作为程序的输入；& w & 表示程序的输出作为命令的输入。另外要注意用pclose( ) 关闭文件流。两个函数出错
#include&stdio.h&
#include&stdlib.h&
#include&sys/types.h&
#include&memory.h&
#include&signal.h&
int main(){
int pfd[2];
char *cmd=&ls -l&;
char buf[100];
if((fp=popen(cmd,&r&)) == NULL){
printf(&popen error\n&);
while(fgets(buf,100,fp)!= NULL){
printf(&from fp:%s&,buf);
pclose(fp);
&&&&&c、有名管道FIFO
&&&&&& 读数据的程序：
#include&stdio.h&
#include&fcntl.h&
#include&unistd.h&
#include&memory.h&
#include&errno.h&
#include&stdlib.h&
#define FIFO &pipetest&
int main(int argc,char* argv[]){
char buff[1024];
if(access(FIFO,F_OK)==-1){
//判断管道是否存在，管道是不可以重复创建的
if(mkfifo(FIFO,0666)&0){
if(errno==EEXIST)
printf(&it already exist\n&);
printf(&create fifo error! it already exist\n&);
if((fd=open(&in1&,O_RDONLY))&0){
printf(&open in1 error!\n&);
memset(buff,0,1024);
if(r=read(fd,buff,1024)&0){
printf(&send to name pipe: %s\n&,buff);
close(fd);
&&&&&& 写数据的程序：
#include&stdio.h&
#include&fcntl.h&
#include&unistd.h&
#include&memory.h&
#include&errno.h&
#include&stdlib.h&
#define FIFO &pipetest&
int main(int argc,char* argv[]){
char buff[1024];
if(argc&2){
printf(&Usage: ./%s &string&\n&,argv[0]);
sscanf(argv[1],&%s&,buff);
if(access(FIFO,F_OK)==-1){
if(mkfifo(FIFO,0666)&0){
if(errno==EEXIST)
printf(&it already exist\n&);
printf(&create fifo error!\n&);
if((fd=open(&in1&,O_WRONLY))&0){
printf(&open in1 error!\n&);
if(w=write(fd,buff,1024)&0){
printf(&send to name pipe: %s\n&,buff);
close(fd);
&&&&&&&&&&& 3、信号量
&&&&&&&&&& 信号量和信号通信( Signal )可不一样。信号量( Semaphore ) 是用于解决不同程序间的访问问题。即同步和互斥。
&&&&&&&&&& 同步是指多线程程序按照一定的顺序执行一段完整的代码。互斥指多线程程序访问同一个变量时只能有一个线程在访问。
&&&&&&&&&&&&&&&& 信号量就是为了解决同步和互斥的IPC机制，信号量为0则没有资源，进程进入等待队列，直到资源被释放为止。
&&&&&&&&&&& 信号量编程的步骤：
&&&&&&&&&&&&&&& 1、创建信号量或获得在系统中已经存在的信号量
&&&&&&&&&&&&&&&&&&&&&&&&& 调用semget () 函数&。使用同一个信号量键值即可获得同一个信号量。
&&&&&&&&&&&&&&&& 2、初始化信号量
&&&&&&&&&&&&&&&&&&&&&&&&& 使用semctl( ) 函数的SETVAL。当使用二维信号量时，初始化为1。
&&&&&&&&&&&&&&&&&3、进行信号量的PV操作
&&&&&&&&&&&&&&&&&&&&&&&&& 调用semop( ) 。实现同步与互斥。
&&&&&&&&&&&&&&&& 4、不需要信号量则从系统中删除
&&&&&&&&&&&&&&&&&&&&&&&&& 使用semclt( ) 函数的IPC_RMID 。
&&&&&&&&&& 一个操作方法的封装函数文件：&&&&&
#include&stdio.h&
#include&fcntl.h&
#include&unistd.h&
#include&memory.h&
#include&errno.h&
#include&stdlib.h&
#define FIFO &pipetest&
int main(int argc,char* argv[]){
char buff[1024];
if(argc&2){
printf(&Usage: ./%s &string&\n&,argv[0]);
sscanf(argv[1],&%s&,buff);
if(access(FIFO,F_OK)==-1){
if(mkfifo(FIFO,0666)&0){
if(errno==EEXIST)
printf(&it already exist\n&);
printf(&create fifo error! it already exist\n&);
if((fd=open(&in1&,O_WRONLY))&0){
printf(&open in1 error!\n&);
if(w=write(fd,buff,1024)&0){
printf(&send to name pipe: %s\n&,buff);
close(fd);
&&&&&&&&&&&&&&&& 调用的例子：
#include&stdio.h&
#include&stdlib.h&
#include&sys/types.h&
#include&sys/ipc.h&
#include&sys/sem.h&
#include&semcom.c&
int main(){
if((semid=semget(ftok(&.&,'a'),1,0666|IPC_CREAT))&0){
//创建信号量
printf(&semget error!\n&);
init_sem(semid,1);
if((pid = fork())&0){
printf(&fork error!\n&);
}else if(pid == 0){
sem_p(semid);
//在未释放之前父进程无法访问
printf(&child is running......\n&);
printf(&son is %d
wake\n&,getpid());
sem_v(semid);
sem_p(semid);
printf(&parent is running......\n&);
printf(&parent is %d
wake\n&,getpid());
sem_v(semid);
del_sem(semid);
&&&&&&&&&&&&&&&&&&&&&&&&
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：696902次
积分：7623
积分：7623
排名：第880名
原创：159篇
转载：19篇
评论：465条
左手代码右手艺术 追求新浪潮。
致力于将现实变成未来的样子
个人网站：
Cocos2d-x@North Blue:
我的新书已经上市了
感兴趣的童鞋点过来
文章：18篇
阅读：346543
文章：15篇
阅读：65744
(1)(1)(1)(3)(1)(1)(1)(2)(6)(8)(1)(4)(2)(7)(10)(7)(3)(3)(1)(3)(1)(4)(11)(15)(21)(27)(29)(1)(3)linux中，管道能够在同一进程中进行通信吗？
答案是否定的。
管道是用于不同进程之间通信，不能再同一进程中进行通信。
同一进程中，直接进行参数传递就行了，不设计通信问题。
不同进程之间才需要通信，通信类别有多种，如管道、共享内容。其中，管道又有匿名管道和命名管道之分。
匿名管道一般以pipe(fd[2])的形式生成一个管道，两端分别用于读和写。匿名管道只能用于父子进程之间或兄弟进程之间通信，不存在亲缘关系的进程之间不可以用匿名管道。
命名管道一般用mkfifo(fifoname, mode)的形式生成，同一管道的读和写端要在不同的线程中。
我的初学经验
在学习管道通信的时候，我费了不少周折，只因我没有明确管道要用于不同进程之间通信这一概念。
我的开发环境是：windows 7 + virtualbox + fedora 15 kde +&qt-4.7.4
+ qtcreator-2.3.1
1.失败方案
建立一个Qt Gui工程，在三个槽函数中分别实现创建命名管道、写命名管道、读命名管道。并在UI上创建三个按钮，分别绑定这三个槽函数。
测试发现，创建命名管道成功，但打开进行读写的时候就出现错误。
2.成功方案
建立两个Qt工程（GUI或Console型均可），相当于建立了两个进程。在两个工程中，分别实现对同一命名管道的读和写，即读和写在不同的工程中。
运行着两个程序，可以在这两个工程中进行通信。
此外，如果在同一进程使用命名管道或匿名管道，要使用fork()函数，建立具有亲缘关系的两个进程。读和写要在两个不同的进行中进行。
版权声明：自由转载-非商用-非衍生-保持署名 |&
博客网址：
博 & & & 主： lyc_daniel
寄 & & & 语：神爱世人，甚至将他的独生子（耶稣）赐给他们，叫一切信他的，不至灭亡，反得永生。（圣经·约翰福音3:16）
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：227699次
积分：3746
积分：3746
排名：第3038名
原创：130篇
转载：70篇
评论：20条
(1)(1)(1)(1)(6)(2)(1)(2)(9)(7)(39)(40)(14)(25)(20)(11)(5)(3)(4)(16)