进程之间的通信实验
实验：进程之间的通信管道
1．Pipe函数与进程通信
下面实验为使用管道进行父子进程间通信。
程序首先判断参数是否合法，因为输入的字符将从父进程通过发送到子进程中。
然后，调用pipe函数创建父子进程用于通信的管道。
使用fork函数创建子进程时，子进程会获得与父进程相同的资源，其中包括文件描述符信息。
因此，调用fork函数须在pipe函数调用前。
当父子进程通过管道进行通信时，files[1]为用于数据写入的文件描述符.因此,在子进程中,要读取管道中的数据可以调用read函数，而读取得文件描述符为files[0]。
对于父进程而言，写入数据需要调用write 函数，要写入的文件描述为files[1]。
#include <stdio.h>
#include <unistd.h>
int main(int argc,char* argv[])
{
int f_des[2];
int pid;
char msg[BUFSIZ];
if(argc!=2){
printf("Usage: %s message\n",argv[0]);
return 1;
}
if(pipe(f_des)==-1){
perror("cannot create the IPC pipe");
return 1;
}
pid=fork();
if(pid==-1){
perror("cannot create new process");
return 1;
}else if(pid==0){
close(f_des[1]);
if(read(f_des[0],msg,BUFSIZ)==-1){
perror("child process cannot read data from pipe");
return 1;
}else
printf("in child process, receive message: %s\n",msg);
_exit(0);
}else {
close(f_des[0]);
if(write(f_des[1],argv[1],strlen(argv[1]))==-1){
perror("parent process cannot write data to pipe");
return 1;
}else
printf("in parent process, send message: %s\n",argv[1]);
wait(NULL);
_exit(0);
}
return 0;
}
2. Shell管道重订向的实现
实现了在SHELL中的两个命令的组合。
如：“Is|less”可以实现文件列表的分页显示，程序实现的泪是命令为“Is more”.是通过调用dup2函数，将创建的管道的读写文件描述符重定向到标准输入输出。
#include <stdio.h>
#include <unistd.h>
int main(int argc,char* argv[])
{
int f_des1[2];
int f_des2[2];
int pid;
char msg[BUFSIZ];
char p_msg[BUFSIZ];
if(argc!=2){
printf("Usage: %s message\n",argv[0]);
return 1;
}
if(pipe(f_des1)==-1){
perror("cannot create the IPC pipe");
return 1;
}
if(pipe(f_des2)==-1){
perror("cannot create the IPC pipe");
return 1;
}
pid=fork();
if(pid==-1){
perror("cannot create new process");
return 1;
}else if(pid==0){
close(f_des1[1]);
close(f_des2[0]);
//read data from the parent process
if(read(f_des1[0],msg,BUFSIZ)==-1){
perror("child process cannot read data from pipe");
return 1;
}else
printf("in child process, receive message: %s\n",msg);
//write data to the parent process
if(write(f_des2[1],msg,strlen(msg))==-1){
perror("child process cannot write data to pipe");
return 1;
}else
printf("in child process, send message back: %s\n",argv[1]);
_exit(0);
}else {
close(f_des1[0]);
close(f_des2[1]);
//write data to the child process
if(write(f_des1[1],argv[1],strlen(argv[1]))==-1){
perror("parent process cannot write data to pipe");
return 1;
}else
printf("in parent process, send message: %s\n",argv[1]);
//read data from the cild process
if(read(f_des2[0],p_msg,BUFSIZ)==-1){
perror("parent process cannot read data from pipe");
return 1;
}else
printf("in parent process, receive message: %s\n",p_msg);
wait(NULL);
_exit(0);
}
return 0;
}。
实验四 进程间通信实验(一)
实验四进程间通信实验（一）实验目的：1.通过基础实验，基本掌握共享内存的程序设计。
2.通过编写程序，使读者掌握消息队列的设计方法。
实验内容：1.共享内存程序设计：创建两个进程，在A进程中创建一个共享内存，并向其写入数据，通过B进程从共享内存中读出数据。
2.消息队列程序设计：创建一个消息队列，如何使用消息队列进行两个进程（发送端和接受端）之间的通信，包括消息队列的创建、消息发送与读取、消息队列的撤销和删除等多种操作。
实验过程：（一）共享内存程序设计❝函数说明：共享内存的实现分为两个步骤，第一步是创建共享内存，这里用到的函数是shmget()，也就是从内存中获得一段共享内存区域。
第二步映射共享内存，也就是把这段创建的共享内存映射到具体的进程空间中，这里使用的函数是shmat()。
到这里，就可以使用这段共享内存了，也就是可以使用不带缓冲的I/O读写命令对其进行操作。
除此之外，当然还有撤销映射的操作，其函数为shmdt()。
❝共享内存的用法：使用共享内存进行进程间通信一般要经历下面几个步骤：[1]分配：进程通过调用shmget来分配一个共享内存块。
[2]映射：要让一个进程获取对一块共享内存的访问，这个进程必须先调用shmat映射共享内存。
[3]脱离与释放：当进程结束使用共享内存时，使用shmdt使共享内存脱离进程。
当不再需要共享内存时，使用shmctl（sid，IPC_RMID，0）删除它。
实验步骤及代码：1）自己建立文件夹，然后分别编辑shm_com.h、shm1.c、shm2.c./*shm_com.h*/#define TEXT_SZ 2048struct shared_use_st{int written_by_you;char some_text[TEXT_SZ];};--------------------------------------------------------------------------------------------------------------------功能描述：本程序申请和分配共享内存，然后轮询并读取共享内存中的数据，直至读到“end”/*shm1.c*/#include<unistd.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#include "shm_com.h"int main(void){int running=1;void *shared_memory=(void *)0;struct shared_use_st *shared_stuff;int shmid;/*创建共享内存*/shmid=shmget((key_t) 1234,sizeof(struct shared_use_st),0666|IPC_CREAT);if(shmid==-1){fprintf(stderr,"shmget failed\n");exit(EXIT_FAILURE);}/*映射共享内存*/shared_memory=shmat(shmid,(void *)0,0);if(shared_memory==(void *)-1){fprintf(stderr,"shmat failed\n");exit(EXIT_FAILURE);}printf("Memory attached at %X\n",(int)shared_memory);/*让结构体指针指向这块共享内存*/shared_stuff=(struct shared_use_st *)shared_memory;/*控制读写顺序*/shared_stuff->written_by_you=0;/*循环地从共享内存中读数据，直到读到“end”为止*/while(running){if(shared_stuff->written_by_you){printf("You wrote:%s",shared_stuff->some_text);/*读进程睡眠1秒，同时会导致写进程睡眠1秒，做到先读后写*/sleep(1);shared_stuff->written_by_you=0;if(strncmp(shared_stuff->some_text,"end",3)==0){running=0;//结束循环}}}/*删除共享内存*/if(shmdt(shared_memory)==-1){fprintf(stderr,"shmdt failed\n");exit(EXIT_FAILURE);}exit(EXIT_SUCCESS);}----------------------------------------------------------------------------------------------------------------功能描述：本程序申请了上一段程序相同的共享内存，然后循环地向共享内存中写数据，直至写入“end”/*shm2.c*/#include<unistd.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>#include "shm_com.h"int main(void){int running=1;void *shared_memory=(void *)0;struct shared_use_st *shared_stuff;char buffer[BUFSIZ];int shmid;/*创建共享内存*/shmid=shmget((key_t) 1234,sizeof(struct shared_use_st),0666|IPC_CREAT);if(shmid==-1){fprintf(stderr,"shmget failed\n");exit(EXIT_FAILURE);}/*映射共享内存*/shared_memory=shmat(shmid,(void *)0,0);if(shared_memory==(void *)-1){fprintf(stderr,"shmat failed\n");exit(EXIT_FAILURE);}printf("Memory attached at %X\n",(int)shared_memory); /*让结构体指针指向这块共享内存*/shared_stuff=(struct shared_use_st *)shared_memory;/*循环地向共享内存中写入数据，直到写入的为“end”为止*/ while(running){while(shared_stuff->written_by_you==1){sleep(1); //等到读进程读完之后再写printf("waiting for client...\n");}printf("ENter some text:");fgets(buffer,BUFSIZ,stdin);strncpy(shared_stuff->some_text,buffer,TEXT_SZ);shared_stuff->written_by_you=1;if(strncmp(buffer,"end",3)==0){running=0; //结束循环}}/*删除共享内存*/if(shmdt(shared_memory)==-1){fprintf(stderr,"shmdt failed\n");exit(EXIT_FAILURE);}exit(EXIT_SUCCESS);}2）使用gcc shm1.c –o shm1和gcc shm2.c –o shm2 分别编译shm1.c和shm2.c3）在一个终端运行shm1，在另一个终端运行shm2。
实验三-进程通讯实验报告
实验三进程通讯实验报告【姓名】【学号】【实验题目】进程通讯——消息队列与共享存储区【实验目的】（1）掌握进程间通讯的编程方法；（2）加深对进程并发执行的理解；（3）学习利用消息队列和共享存储区实现进程通信的方法。
【实验内容】设计一个多进程并发运行的程序，它由不同的进程完成下列工作：（1）接收键盘输入进程负责接收用户的键盘输入，并以适当的方式将由键盘获得的数据交给其它进程处理。
（2）显示进程负责全部数据显示任务，包括键盘输入数据的显示和提示信息的显示。
（3）分发数据进程将键盘输入的数据分为3类，即字母、数字和其它，并分别将字母写入文件letter.txt 中，数字写入文件number.txt中，除字母和数字外其它数据丢弃。
【实验要求】1、程序能以适当的方式提示用户输入数据；2、提示用户有数据被丢弃；3、全部的显示任务必须由显示进程完成；4、整个程序能够连续处理多组输入数据，直到用户输入“quit”字符串，整个程序结束；5、进一步要求：同时采用共享存储区和消息2种方法实现进程之间的通信，并比较这2种通信方法的利弊。
【实验方法】1、利用fork()函数创建2个子进程，用一个父进程和两个子进程完成上面的三个实验任务，用子进程1实现分发数据任务，子进程2实现接受键盘输入任务，父进程实现全部的显示任务。
2、同时通过共享存储区和消息队列两种进程通讯方式实现上面三个进程之间的同步和互斥。
3、利用while()循环、kill()函数和signal()函数实现连续多组数据输入。
【程序结构】·数据结构：消息队列、字符数组；·程序结构：顺序结构、if-else分支结构和while循环结构；·主要算法：无特别算法【实验结果】1、有代表性的执行结果：[stud13@localhost stud13]$ cc ipc.c[stud13@localhost stud13]$ ./a.outPlease input a line:∟operatingsystem01234-=,.Your message is:operatingsystem01234-=,.The characters deserted are:-=,.Please input a line:∟xushengju6651001!@#$%^&*()Your message is:xushengju6651001!@#$%^&*()The characters deserted are:!@#$%^&*()Please input a line:∟Hello123Your message is:Hello123Please input a line:∟quit[stud13@localhost stud13]$ cat letter.txtOperatingsystemxushengjuHello[stud13@localhost stud13]$ cat number.txt 012346651001123[stud13@localhost stud13]$2、结果分析及解释：在创建子进程1时，由于先返回子进程的ID号，msgrcv(msgid,&msg,BUFSIZE,0,0)一直都是非0值，故循环等待。
实验5 进程间通信实验
实验五进程间通信实验一、实验目的1、了解什么是信号。
2、熟悉LINUX系统中进程之间软中断通信的基本原理。
3、了解什么是管道4、熟悉UNIX/LINUX支持的管道通信方式二、实验内容1、编写一段程序，使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按ctrl+c键），当捕捉到中断信号后，父进程用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：Child process 1 is killed by parent!Child process 2 is killed by parent!父进程等待两个子进程终止后，输出以下信息后终止：Parent process is killed!<参考程序>#include<stdio.h>#include<signal.h>#include<unistd.h>#include<sys/types.h>#include<sys/wait.h>int wait_mark;void waiting(),stop();void main(){int p1, p2;signal(SIGINT,stop);while((p1=fork())==-1);if(p1>0) /*在父进程中*/{while((p2=fork())==-1);If(p2>0) /*在父进程中*/{wait_mark=1;waiting(0);kill(p1,10);kill(p2,12);wait( );wait( );printf("parent process is killed!\n");exit(0);}else /*在子进程2中*/{wait_mark=1;signal(12,stop);waiting();lockf(1,1,0);printf("child process 2 is killed by parent!\n");lockf(1,0,0);exit(0);}}else /*在子进程1中*/{wait_mark=1;signal(10,stop);waiting();lockf(1,1,0);printf("child process 1 is killed by parent!\n");lockf(1,0,0);exit(0);}}void waiting(){while(wait_mark!=0);}void stop(){wait_mark=0;}实验要求：⑴运行程序并分析结果。
实验五 进程通信
（2）读管道 在管道创建后，希望从管道中读取数据的进程使 用读文件描述符fd[0]作为参数，调用read( )系统调用。 #include <unistd.h> ssize_t read(int fd,void *buf,size_t nbytes); 返回：读到的字节数，若已到文件尾为0，若出错 为-1。 （3）写管道 向管道中写入数据的进程使用写文件描述符fd[1] 作为参数，调用write( )系统调用。 #include <unistd.h> ssize_t write(int fd,const void *buf,size_t nbytes); 返回：若成功为已写的字节数，若出错为-1。
2. 管道是UNIX系统中最早为两个进程之间提 供的一种通信机制。管道是一种单向的、先入 先出的、无结构的、大小固定的通信通道。写 进程在管道的一端写入数据，读进程从管道的 另一端读出数据。如果两个或多个进程同时对 一个进程进行读写，那么这些进程必须使用锁 机制或者信号量机制对其进行同步。 管道分为无名管道和有名管道。无名管道 没有名字，所以只能提供给进程家族中的父子 进程间通信使用，而有名管道则用于没有家族 关系的任意两个进程之间的通信。
wait(0); read(fd[0], inpipe, 50); printf(“%s\n”, inpipe); wait(0); read(fd[0], inpipe, 50); printf(“%s\n”, inpipe); exit(0);
}
} }Байду номын сангаас四. 试验总结
1. 写出试验报告。 2. 为程序添加注释。 3. 分析信号通信和管道通信各自的特点。
2. 编写一段程序，实现进程的管道通信。 使用系统调用pipe( )建立一条管道，创建两个子进程 P1和P2。 让P1和P2分别向管道各写一句话： Child 1 is sending a message! Child 2 is sending a message! 父进程则从管道中读出来自于两个子进程的信息， 显示在屏幕上。要求：父进程先接受子进程P1发来的 消息，然后再接受子进程P2发来的消息。 参考程序如下：
实验五：进程间通信
实验五：进程间通信实验五：进程间通信●实验目的：学会进程间通信方式：无名管道，有名管道，信号，共享内存●实验要求：（一）在父进程中创建一无名管道，并创建子进程来读该管道，父进程来写该管道（二）在进程中为SIGBUS注册处理函数，并向该进程发送SIGBUS信号（三）创建一共享内存，实现放进程间通信●实验器材：软件：安装了Linux的vmware虚拟机硬件：PC机一台●实验步骤：（一）无名管道的使用1、编写实验代码pipe_rw.c#include#include#include#include#include#includeint main(){int pipe_fd[2];pid_t pid;char buf_r[100];char* p_wbuf;int r_num;memset(buf_r,0,sizeof(buf_r));/*创建管道*/if(pipe(pipe_fd)<0){printf("pipe create error\n");return -1;}/*创建子进程*/if((pid=fork())==0) //子进程执行代码{//1、子进程先关闭了管道的写端//2、让父进程先运行，这样父进程先写子进程才有内容读//3、读取管道的读端，并输出数据//4、关闭管道的读端，并退出}else if(pid>0) //父进程执行代码{//1、父进程先关闭了管道的读端//2、向管道写入字符串数据//3、关闭写端，并等待子进程结束后退出}return 0;}2、编译应用程序pipe_rw.c3、运行应用程序子进程先睡两秒让父进程先运行，父进程分两次写入“hello”和“pipe”，然后阻塞等待子进程退出，子进程醒来后读出管道里的内容并打印到屏幕上再退出，父进程捕获到子进程退出后也退出4、由于fork函数让子进程完整地拷贝了父进程的整个地址空间，所以父子进程都有管道的读端和写端。
进程实验-进程间通信(管道、消息、共享内存、软中断)
进程实验3 Linux 进程间通信一、软中断信号的处理，实现同一用户的各进程之间的通信。
●相关的系统调用⏹kill(pid ,sig)：发送信号⏹signal（sig, func）：指定进程对信号sig的处理行为是调用函数func。
●程序清单#include <unistd.h>#include <stdio.h>#include <signal.h>void waiting();void stop();int wait_mark;main(){int p1,p2;while((p1=fork())==-1);if(p1>0){while((p2=fork())==-1);if(p2>0){ printf("parent\n");/*父进程在此完成某个操作、或接收到用户从键盘输入的特殊按键命令后发出下面的信号。
这里省略。
*/kill(p1,16);kill(p2,17);wait(0);wait(0);printf("parent process id killed! \n");exit(0);}else/* p2==0*/{printf("p2\n");wait_mark=1;signal(17,stop);waiting();printf("child process 2 is killed by parent! \n");exit(0);}}else/*p1==0*/{printf("p1\n");wait_mark=1;signal(16,stop);waiting();printf("child process 1 is kelled by parent! \n");exit(0);}}void waiting(){while(wait_mark!=0);}void stop(){wait_mark=0;}●输入并运行此程序，分析程序的运行结果。
实验6 进程间通信
实验6 进程间通信一、实验目的：通过本实验了解和掌握进程间通讯的相关知识，（1）了解进程通信的基本原理。
（2）了解和熟悉管道通信，消息传送机制及共享存储机制。
二．实验内容1.进程的管道通信阅读下列程序，完成实验任务。
#include<unistd.h>#include<signal.h>#include<stdio.h>int pid1,pid2;main(){int fd[2];char outpipe[100],inpipe[100];pipe(fd); //将fd装入管道中while((pid1=fork())==-1); //如果进程没有创建成功，则一直循环if(pid1==0) //如果是子进程{lockf(fd[1],1,0);sprintf(outpipe,"chile 1 process a message!");//将字符串读入到oupipe中去write(fd[1],outpipe,50); //将outpipe写入到fd[1]中sleep(5); //睡眠5秒lockf(fd[1],0,0);exit(0);}else //是父进程{while((pid2=fork())==-1);if(pid2 == 0) //进程创建成功，并且是子进程{lockf(fd[1],1,0);sprintf(outpipe,"child 2 process is sending a message!");write(fd[1],outpipe,50);sleep(5);lockf(fd[1],0,0);exit(0);}else{wait(0); //等待进程read(fd[0],inpipe,50); //将inpipe读入fd[0]中去，printf("%s\n",inpipe); //打印出子进程2wait(0);read(fd[0],inpipe,50);printf("%s\n",inpipe); //打印出子进程1exit(0);}}}实验任务：（1），读懂上面的程序，编译执行，分析为什么会出现这样的结果。
进程通信的实验报告
一、实验目的1. 理解进程通信的概念和作用。
2. 掌握进程通信的常用方法，包括管道、消息队列、信号量等。
3. 通过编程实践，加深对进程通信机制的理解和应用。
二、实验环境操作系统：Linux开发环境：gcc三、实验内容1. 管道通信2. 消息队列通信3. 信号量通信四、实验步骤及分析1. 管道通信（1）实验步骤1）创建一个父进程和一个子进程；2）在父进程中创建一个管道，并将管道的读端和写端分别赋给父进程和子进程；3）在父进程中，通过管道的写端发送数据给子进程；4）在子进程中，通过管道的读端接收父进程发送的数据；5）关闭管道的读端和写端；6）结束进程。
（2）实验分析通过管道通信，实现了父进程和子进程之间的数据传递。
管道是半双工通信，数据只能单向流动。
在本实验中，父进程向子进程发送数据，子进程接收数据。
2. 消息队列通信（1）实验步骤1）创建一个消息队列；2）在父进程中，向消息队列中发送消息；3）在子进程中，从消息队列中接收消息；4）删除消息队列；5）结束进程。
（2）实验分析消息队列是一种进程间通信机制，允许不同进程之间传递消息。
消息队列的创建、发送、接收和删除等操作都是通过系统调用实现的。
在本实验中，父进程向消息队列发送消息，子进程从消息队列接收消息，实现了进程间的消息传递。
3. 信号量通信（1）实验步骤1）创建一个信号量；2）在父进程中，对信号量执行P操作，请求资源；3）在子进程中，对信号量执行V操作，释放资源；4）结束进程。
（2）实验分析信号量是一种用于实现进程同步的机制。
在进程通信中，信号量可以用来协调多个进程对共享资源的访问。
在本实验中，父进程和子进程通过信号量实现了对共享资源的同步访问。
五、实验结果1. 管道通信实验结果：父进程成功向子进程发送数据，子进程成功接收数据。
2. 消息队列通信实验结果：父进程成功向消息队列发送消息，子进程成功从消息队列接收消息。
3. 信号量通信实验结果：父进程成功获取资源，子进程成功释放资源。
进程通讯管理实验报告(3篇)
第1篇一、实验目的1. 理解进程通信的概念和原理；2. 掌握进程通信的常用机制和方法；3. 能够使用进程通信机制实现进程间的数据交换和同步；4. 增强对操作系统进程管理模块的理解。
二、实验环境1. 操作系统：Linux2. 编程语言：C3. 开发环境：GCC三、实验内容1. 进程间通信的管道机制2. 进程间通信的信号量机制3. 进程间通信的共享内存机制4. 进程间通信的消息队列机制四、实验步骤1. 管道机制（1）创建管道：使用pipe()函数创建管道，将管道文件描述符存储在两个变量中，分别用于读和写。
（2）创建进程：使用fork()函数创建子进程，实现父子进程间的通信。
（3）管道读写：在父进程中，使用read()函数读取子进程写入的数据；在子进程中，使用write()函数将数据写入管道。
（4）关闭管道：在管道读写结束后，关闭对应的管道文件描述符。
2. 信号量机制（1）创建信号量：使用sem_open()函数创建信号量，并初始化为1。
（2）获取信号量：使用sem_wait()函数获取信号量，实现进程同步。
（3）释放信号量：使用sem_post()函数释放信号量，实现进程同步。
（4）关闭信号量：使用sem_close()函数关闭信号量。
3. 共享内存机制（1）创建共享内存：使用mmap()函数创建共享内存区域，并初始化数据。
（2）映射共享内存：在父进程和子进程中，使用mmap()函数映射共享内存区域。
（3）读写共享内存：在父进程和子进程中，通过指针访问共享内存区域，实现数据交换。
（4）解除映射：在管道读写结束后，使用munmap()函数解除映射。
4. 消息队列机制（1）创建消息队列：使用msgget()函数创建消息队列，并初始化消息队列属性。
（2）发送消息：使用msgsnd()函数向消息队列发送消息。
（3）接收消息：使用msgrcv()函数从消息队列接收消息。
（4）删除消息队列：使用msgctl()函数删除消息队列。
实验三 进程间的通信
实验三进程间的通信1、实验目的学习如何利用管道机制、消息缓冲队列进行进程间的通信，并加深对上述通信机制的理解。
2、实验内容（1）了解系统调用pipe()、msgget()、msgsnd()、msgrcv()的功能和实现过程。
（2）编写一段程序，使其用管道来实现父子进程之间的进程通信。
子进程向父进程发送自己的进程标识符，以及字符串“is sending a message to parent!”。
父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。
（3）编写一段程序，使用消息缓冲队列来实现client进程和server进程之间的通信。
server进程先建立一个关键字为SVKEY （如75）的消息队列，然后等待接收类型为REQ（如1）的消息；在收到请求消息后，它便显示字符串“serving for client”和接收到的client进程的进程标识数，表示正在为client进程服务；然后再向client进程发送一应答消息，该消息类型是client 进程的进程标识数，而正文则是server进程自己的标识数。
client进程则向消息队列发送类型为REQ的消息（消息的正文为自己的进程标识数）以取得server进程的服务，并等待server 进程发来的应答；然后显示字符串“receive reply form”和接收到的server进程的标识符。
1、client.c2、server.c3、思考题上述通信机制各有什么特点？它们分别适合于何种场合？答：管道通信的特点：（1）管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；（2）只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；（3）单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
（4）数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。