血魔 炼金 大牛 冰龙:Linux下进程间通信:管道-pipe函数(转载转载)
来源:百度文库 编辑:九乡新闻网 时间:2024/05/01 07:51:30
摘要:在本系列序中作者概述了 linux 进程间通信的几种主要手段。其中管道和有名管道是最早的进程间通信机制之一,管道可用于具有亲缘关系进程间的通信,有名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关系进程间的通信。 认清管道和有名管道的读写规则是在程序中应用它们的关键,本文在详细讨论了管道和有名管道的通信机制的基础上,用实例对其读写规则进行了程序验证,这样做有利于增强读者对读写规则的感性认识,同时也提供了应用范例。本文来自网络,但原文出处难以查证。
目录 [隐藏]- 管道相关的关键概念
- 管道的创建
- 管道的读写规则
- 管道应用实例
- 用于shell
- 用于具有亲缘关系的进程间通信
管道相关的关键概念
管道是Linux支持的最初Unix IPC形式之一,具有以下特点:
- 管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道;
- 只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程);
- 单独构成一种独立的文件系统:管道对于管道两端的进程而言,就是一个文件,但它不是普通的文件,它不属于某种文件系统,而是自立门户,单独构成一种文件系统,并且只存在与内存中。
- 数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾,并且每次都是从缓冲区的头部读出数据。
管道的创建
#include 该函数创建的管道的两端处于一个进程中间,在实际应用中没有太大意义,因此,一个进程在由pipe()创建管道后,一般再fork一个子进程,然后通过管道实现父子进程间的通信(因此也不难推出,只要两个进程中存在亲缘关系,这里的亲缘关系指的是具有共同的祖先,都可以采用管道方式来进行通信)。 管道两端可分别用描述字fd[0]以及fd[1]来描述,需要注意的是,管道的两端是固定了任务的。即一端只能用于读,由描述字fd[0]表示,称其为管道读端;另一端则只能用于写,由描述字fd[1]来表示,称其为管道写端。如果试图从管道写端读取数据,或者向管道读端写入数据都将导致错误发生。一般文件的I/O函数都可以用于管道,如close、read、write等等。 从管道中读取数据: 关于管道的读规则验证:/************** * readtest.c * **************/ 程序输出结果: 向管道中写入数据: 管道的写规则的验证一://写端对读端存在的依赖性 则输出结果为: Broken pipe,原因就是该管道以及它的所有fork()产物的读端都已经被关闭。如果在父进程中保留读端,即在写完pipe后,再关闭父进程的读端,也会正常写入pipe,读者可自己验证一下该结论。因此,在向管道写入数据时,至少应该存在某一个进程,其中管道读端没有被关闭,否则就会出现上述错误(管道断裂,进程收到了SIGPIPE信号,默认动作是进程终止) 对管道的写规则的验证二://linux不保证写管道的原子性验证 输出结果: the bytes write to pipe 1000 the bytes write to pipe 1000 ,此行输出说明了写入的非原子性 结论: 写入数目小于4096时写入是非原子的! 如果把父进程中的两次写入字节数都改为5000,则很容易得出下面结论:写入管道的数据量大于4096字节时,缓冲区的空闲空间将被写入数据(补齐),直到写完所有数据为止,如果没有进程读数据,则一直阻塞。 管道可用于输入输出重定向,它将一个命令的输出直接定向到另一个命令的输入。比如,当在某个shell程序(Bourne shell或C shell等)键入who│wc -l后,相应shell程序将创建who以及wc两个进程和这两个进程间的管道。考虑下面的命令行: 下面例子给出了管道的具体应用,父进程通过管道发送一些命令给子进程,子进程解析命令,并根据命令作相应处理。 管道的主要局限性正体现在它的特点上:
int pipe(int fd[2])
返回:成功,0;失败,-1管道的读写规则
#include
#include
#include
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(r_buf));
p_wbuf = w_buf;
if(pipe(pipe_fd) < 0)
{
printf("pipe create error\n");
return -1;
}
if((pid = fork()) == 0)
{
printf("\n");
close(pipe_fd[1]);
sleep(3); //确保父进程关闭写端
r_num = read(pipe_fd[0], r_buf, 100);
printf("read num is %d the data read from the pipe is %d\n", 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\n");
close(pipe_fd[1]);//write
printf("parent close fd[1] over\n");
sleep(10);
}
}
parent write over
parent close fd[1] over
read num is 4 the data read from the pipe is 111
附加结论:管道写端关闭后,写入的数据将一直存在,直到读出为止。
#include
#include
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\n");
return -1;
}
if((pid = fork()) == 0)
{//子进程
close(pipe_fd[0]);//读端关闭
close(pipe_fd[1]);//写端关闭
sleep(10);
exit();
} else if(pid > 0) {
//父进程
sleep(1);
close(pipe_fd[0]);
w_buf="111";
if((writenum = write(pipe_fd[1], w_buf, 4)) == -1)
printf("write to pipe error\n");
else
printf("the bytes write to pipe is %d \n", writenum);
close(pipe_fd[1]);
}
}
#include
#include
#include
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\n");
return -1;
}
if((pid = fork()) == 0)
{
close(pipe_fd[1]);
while(1)
{
sleep(1);
rnum = read(pipe_fd[0], r_buf, 1000);
printf("child: readnum is %d\n", 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\n");
else
printf("the bytes write to pipe is %d \n", writenum);
writenum = write(pipe_fd[1], w_buf, 4096);
close(pipe_fd[1]);
}
}
the bytes write to pipe 1000 the bytes write to pipe 1000 the bytes write to pipe 1000 the bytes write to pipe 120 ,此行输出说明了写入的非原子性
the bytes write to pipe 0 the bytes write to pipe 0 ......管道应用实例
用于shell
$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
#include
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\n");
return -1;
}
if((pid=fork())==0)
{ //子进程:解析从管道中获取的命令,并作相应的处理
printf("\n");
close(pipe_fd[1]);
sleep(2);
while(!childexit)
{
read(pipe_fd[0], r_buf, 4);
cmd = atoi(r_buf);
if(cmd == 0)
{
printf("child: receive command from parent over\n now child process exit\n");
childexit = 1;
}
else if(handle_cmd(cmd) != 0)
return;
sleep(1);
}
close(pipe_fd[0]);
exit();
}
else if(pid > 0)
{ //父进程:发送命令给子进程
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 \n");
return -1;
}
printf("child: the cmd from parent is %d\n", cmd);
return 0;
}管道的局限性