Linux--进程间通信(管道及有名管道FIFO)(转)

一. 管道:

   1.只能用于具有亲缘关系的进程之间的通信  

   2.半双工通信模式

   3.一种特殊的文件,是一种只存在于内核中的读写函数

 

管道基于文件描述符,管道建立时,有两个文件描述符:

a. fd[0]: 固定用于读管道

b. fd[1]: 固定用于写管道

 

创建管道:pipe()

Linux--进程间通信(管道及有名管道FIFO)(转)_第1张图片

     一般步骤:1. pipe()创建管道  2. fork()创建子进程  3. 子进程会继承父进程的管道

 

关闭管道:1. 逐个关闭文件描述符  2. close()

 

eg. 父子进程间的管道通信:父子进程对管道分别有自己的读写通道,把无关的读端或写段关闭。

  

View Code
 1 #include 
2 #include
3 #include <string.h>
4 #include
5 #include
6
7 #define MAX_DATA_LEN 256
8 #define DELAY_TIME 1
9
10 int main() {
11 pid_t pid;
12 char buf[MAX_DATA_LEN];
13 const char *data="Pipe Test program";
14 int real_read,real_write;
15 int pipe_fd[2];
16
17 memset((void*)buf,0,sizeof(buf));
18
19 if(pipe(pipe_fd)<0){
20 perror("Pipe create error!\n");
21 exit(1);
22 }
23
24 if ((pid=fork())<0) {
25 perror("Fork error!\n");
26 exit(1);
27 } else if (pid==0) {
28 close(pipe_fd[1]);
29 sleep(DELAY_TIME*3);
30
31 if ((real_read=read(pipe_fd[0],buf,MAX_DATA_LEN))>0) {
32 printf("Child receive %d bytes from pipe: '%s'.\n",real_read,buf);
33 }
34
35 close(pipe_fd[0]);
36 exit(0);
37 } else {
38 close(pipe_fd[0]);
39 sleep(DELAY_TIME);
40
41 if ((real_write=write(pipe_fd[1],data,strlen(data)))>0) {
42 printf("Parent write %d bytes into pipe: '%s'.\n",real_write,data);
43 }
44
45 close(pipe_fd[1]);
46 waitpid(pid,NULL,0);
47 exit(0);
48 }
49
50 }

 

 

 

二. 有名管道FIFO

  1. 使不相关的两个进程彼此通信:a. 通过路径名指出,在文件系统中可见  

                  b. 管道建立后,两进程可按普通文件一样对其操作

  2. FIFO遵循先进先出规则:a. 对管道读从开始处返回数据

                b. 对管道写则把数据添加到末尾

                c. 不支持如lseek()等文件定位操作

 

  创建有名管道:mkfifo()

 

创建管道成功后,可使用open()、read()和write()等函数。
  为读而打开的管道可在open()中设置O_RDONLY
  为写而打开的管道可在open()中设置O_WRONLY
 
与普通文件不同的是阻塞问题
  •普通文件的读写时不会出现阻塞问题
  •在管道的读写中却有阻塞的可能,
  •非阻塞标志:在open()函数中设定为O_NONBLOCK
 
l 阻塞打开与非阻塞打开
对于读进程
  •若该管道是阻塞打开,且当前FIFO内没有数据,则对读进程而言将一直阻塞到有数据写入
  •若该管道是非阻塞打开,则不论FIFO内是否有数据,读进程都会立即执行读操作。即如果FIFO内没有数据,则读函数将立刻返回0
对于写进程
  •若该管道是阻塞打开,则写操作将一直阻塞到数据可以被写入
  •若该管道是非阻塞打开而不能写入全部数据,则读操作进行部分写入或者调用失败
 
 
eg. 写FIFO与读FIFO
View Code
 1 #include 
2 #include
3 #include <string.h>
4 #include
5 #include
6 #include
7 #include
8 #include
9
10 #define FIFO "myfifo"
11 #define BUFF_SIZE 1024
12
13 int main(int argc,char* argv[]) {
14 char buff[BUFF_SIZE];
15 int real_write;
16 int fd;
17
18 if(argc<=1){
19 printf("Usage: ./fifo_write string\n");
20 exit(1);
21 }
22
23 sscanf(argv[1],"%s",buff);
24
25 % 测试FIFO是否存在,若不存在,mkfifo一个FIFO
26 if(access(FIFO,F_OK)==-1){
27 if((mkfifo(FIFO,0666)<0)&&(errno!=EEXIST)){
28 printf("Can NOT create fifo file!\n");
29 exit(1);
30 }
31 }
32
33 % 调用open以只写方式打开FIFO,返回文件描述符fd
34 if((fd=open(FIFO,O_WRONLY))==-1){
35 printf("Open fifo error!\n");
36 exit(1);
37 }
38
39 % 调用write将buff写到文件描述符fd指向的FIFO中
40 if ((real_write=write(fd,buff,BUFF_SIZE))>0) {
41 printf("Write into pipe: '%s'.\n",buff);
42 exit(1);
43 }
44
45 close(fd);
46 exit(0);
47
48 }
View Code
 1 #include 
2 #include
3 #include <string.h>
4 #include
5 #include
6 #include
7 #include
8 #include
9
10 #define FIFO "myfifo"
11 #define BUFF_SIZE 1024
12
13 int main() {
14 char buff[BUFF_SIZE];
15 int real_read;
16 int fd;
17
18 %access确定文件或文件夹的访问权限。即,检查某个文件的存取方式
19 %如果指定的存取方式有效,则函数返回0,否则函数返回-1
20 %若不存在FIFO,则创建一个
21 if(access(FIFO,F_OK)==-1){
22 if((mkfifo(FIFO,0666)<0)&&(errno!=EEXIST)){
23 printf("Can NOT create fifo file!\n");
24 exit(1);
25 }
26 }
27
28 %以只读方式打开FIFO,返回文件描述符fd
29 if((fd=open(FIFO,O_RDONLY))==-1){
30 printf("Open fifo error!\n");
31 exit(1);
32 }
33
34 % 调用read将fd指向的FIFO的内容,读到buff中,并打印
35 while(1){
36 memset(buff,0,BUFF_SIZE);
37 if ((real_read=read(fd,buff,BUFF_SIZE))>0) {
38 printf("Read from pipe: '%s'.\n",buff);
39 }
40 }
41
42 close(fd);
43 exit(0);
44 }


 
 

转载于:https://www.cnblogs.com/forstudy/archive/2012/03/22/2412415.html

你可能感兴趣的:(Linux--进程间通信(管道及有名管道FIFO)(转))