Linux管道和命名管道

　　本系列序中作者概述了 linux 进程间通信的几种主要手段。其中管道和有名管道是最早的进程间通信机制之一，管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。 认清管道和有名管道的读写规则是在程序中应用它们的关键，本文在详细讨论了管道和有名管道的通信机制的基础上，用实例对其读写规则进行了程序验证，这样做有利于增强读者对读写规则的感性认识，同时也提供了应用范例。

1 管道概述及相关API应用

1.1 管道相关的关键概念

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

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

1.2 管道的创建

　　int pipe(int fd[2])

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

1.3 管道的读写规则

　　管道两端可分别用描述字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）。

向管道中写入数据：

  • 向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞。 
    注：只有在管道的读端存在时，向管道中写入数据才有意义。否则，向管道中写入数据的进程将收到内核传来的SIFPIPE信号，应用程序可以处理该信号，也可以忽略（默认动作则是应用程序终止）。

关于管道的读规则验证：

 1 /**************
 2  * readtest.c *
 3  **************/
 4 #include
 5 #include
 6 #include
 7 main()
 8 {
 9     int pipe_fd[2];
10     pid_t pid;
11     char r_buf[100];
12     char w_buf[4];
13     char* p_wbuf;
14     int r_num;
15     int cmd;
16
17     memset(r_buf,0,sizeof(r_buf));
18     memset(w_buf,0,sizeof(r_buf));
19     p_wbuf=w_buf;
20     if(pipe(pipe_fd)<0)
21     {
22         printf("pipe create error\n");
23         return -1;
24     }
25
26     if((pid=fork())==0)
27     {
28         printf("\n");
29         close(pipe_fd[1]);
30         sleep(3);//确保父进程关闭写端
31         r_num=read(pipe_fd[0],r_buf,100);
32 printf(    "read num is %d   the data read from the pipe is %d\n",r_num,atoi(r_buf));
33
34         close(pipe_fd[0]);
35         exit();
36     }
37     else if(pid>0)
38     {
39     close(pipe_fd[0]);//read
40     strcpy(w_buf,"111");
41     if(write(pipe_fd[1],w_buf,4)!=-1)
42         printf("parent write over\n");
43     close(pipe_fd[1]);//write
44         printf("parent close fd[1] over\n");
45     sleep(10);
46     }
47 }
48  /**************************************************
49  * 程序输出结果：
50  * parent write over
51  * parent close fd[1] over
52  * read num is 4   the data read from the pipe is 111
53  * 附加结论：
54  * 管道写端关闭后，写入的数据将一直存在，直到读出为止.
55  ****************************************************/
56

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

 1 #include
 2 #include
 3 main()
 4 {
 5     int pipe_fd[2];
 6     pid_t pid;
 7     char r_buf[4];
 8     char* w_buf;
 9     int writenum;
10     int cmd;
11
12     memset(r_buf,0,sizeof(r_buf));
13     if(pipe(pipe_fd)<0)
14     {
15         printf("pipe create error\n");
16         return -1;
17     }
18
19     if((pid=fork())==0)
20     {
21         close(pipe_fd[0]);
22         close(pipe_fd[1]);
23         sleep(10);
24         exit();
25     }
26     else if(pid>0)
27     {
28     sleep(1);  //等待子进程完成关闭读端的操作
29     close(pipe_fd[0]);//write
30     w_buf="111";
31     if((writenum=write(pipe_fd[1],w_buf,4))==-1)
32         printf("write to pipe error\n");
33     else
34         printf("the bytes write to pipe is %d \n", writenum);
35
36     close(pipe_fd[1]);
37     }
38 }

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

 1 #include
 2 #include
 3 #include
 4 main(int argc,char**argv)
 5 {
 6     int pipe_fd[2];
 7     pid_t pid;
 8     char r_buf[4096];
 9     char w_buf[4096*2];
10     int writenum;
11     int rnum;
12     memset(r_buf,0,sizeof(r_buf));
13     if(pipe(pipe_fd)<0)
14     {
15         printf("pipe create error\n");
16         return -1;
17     }
18
19     if((pid=fork())==0)
20     {
21         close(pipe_fd[1]);
22         while(1)
23         {
24         sleep(1);
25         rnum=read(pipe_fd[0],r_buf,1000);
26         printf("child: readnum is %d\n",rnum);
27         }
28         close(pipe_fd[0]);
29
30         exit();
31     }
32     else if(pid>0)
33     {
34     close(pipe_fd[0]);//write
35     memset(r_buf,0,sizeof(r_buf));
36     if((writenum=write(pipe_fd[1],w_buf,1024))==-1)
37         printf("write to pipe error\n");
38     else
39         printf("the bytes write to pipe is %d \n", writenum);
40     writenum=write(pipe_fd[1],w_buf,4096);
41     close(pipe_fd[1]);
42     }
43 }
44 /*输出结果：
45 the bytes write to pipe 1000
46 the bytes write to pipe 1000  //注意，此行输出说明了写入的非原子性
47 the bytes write to pipe 1000
48 the bytes write to pipe 1000
49 the bytes write to pipe 1000
50 the bytes write to pipe 120  //注意，此行输出说明了写入的非原子性
51 the bytes write to pipe 0
52 the bytes write to pipe 0
53 ......
54
55 结论：
56 写入数目小于4096时写入是非原子的！
57 如果把父进程中的两次写入字节数都改为5000，则很容易得出下面结论：
58 写入管道的数据量大于4096字节时，缓冲区的空闲空间将被写入数据（补齐），直到写完所有数据为止，如果没有进程读数据，则一直阻塞。*/、

1.4 管道应用实例

实例一：用于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

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

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

 1 #include
 2 #include
 3 main()
 4 {
 5     int pipe_fd[2];
 6     pid_t pid;
 7     char r_buf[4];
 8     char** w_buf[256];
 9     int childexit=0;
10     int i;
11     int cmd;
12
13     memset(r_buf,0,sizeof(r_buf));
14     if(pipe(pipe_fd)<0)
15     {
16         printf("pipe create error\n");
17         return -1;
18     }
19     if((pid=fork())==0)
20     //子进程：解析从管道中获取的命令，并作相应的处理
21     {
22         printf("\n");
23         close(pipe_fd[1]);
24         sleep(2);
25
26         while(!childexit)
27         {
28             read(pipe_fd[0],r_buf,4);
29             cmd=atoi(r_buf);
30             if(cmd==0)
31             {
32 printf("child: receive command from parent over\n now child process exit\n");
33                 childexit=1;
34             }
35
36                else if(handle_cmd(cmd)!=0)
37                 return;
38             sleep(1);
39         }
40         close(pipe_fd[0]);
41         exit();
42     }
43     else if(pid>0)
44     //parent: send commands to child
45     {
46     close(pipe_fd[0]);
47     w_buf[0]="003";
48     w_buf[1]="005";
49     w_buf[2]="777";
50     w_buf[3]="000";
51     for(i=0;i<4;i++)
52         write(pipe_fd[1],w_buf[i],4);
53     close(pipe_fd[1]);
54     }
55 }
56 //下面是子进程的命令处理函数（特定于应用）：
57 int handle_cmd(int cmd)
58 {
59 if((cmd<0)||(cmd>256))
60 //suppose child only support 256 commands
61     {
62     printf("child: invalid command \n");
63     return -1;
64     }
65 printf("child: the cmd from parent is %d\n", cmd);
66 return 0;
67 }

1.5管道的局限性

  • 只支持单向数据流；
  • 只能用于具有亲缘关系的进程之间；
  • 没有名字；
  • 管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
  • 管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；

2.有名管道概述及相关API应用

2.1 有名管道相关的关键概念

　　管道应用的一个重大限制是它没有名字，因此，只能用于具有亲缘关系的进程间通信，在有名管道（named pipe或FIFO）提出后，该限制得到了克服。FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信（能够访问该路径的进程以及FIFO的创建进程之间），因此，通过FIFO不相关的进程也能交换数据。值得注意的是，FIFO严格遵循先进先出（first in first out），对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。

2.2有名管道的创建

　　int mkfifo(const char * pathname, mode_t mode)

　　该函数的第一个参数是一个普通的路径名，也就是创建后FIFO的名字。第二个参数与打开普通文件的open()函数中的mode 参数相同。如果mkfifo的第一个参数是一个已经存在的路径名时，会返回EEXIST错误，所以一般典型的调用代码首先会检查是否返回该错误，如果确实返回该错误，那么只要调用打开FIFO的函数就可以了。一般文件的I/O函数都可以用于FIFO，如close、read、write等等。

2.3有名管道的打开规则

　　有名管道比管道多了一个打开操作：open。

　　FIFO的打开规则：如果当前打开操作是为读而打开FIFO时，若已经有相应进程为写而打开该FIFO，则当前打开操作将成功返回；否则，可能阻塞直到有相应进程为写而打开该FIFO（当前打开操作设置了阻塞标志）；或者，成功返回（当前打开操作没有设置阻塞标志）。如果当前打开操作是为写而打开FIFO时，如果已经有相应进程为读而打开该FIFO，则当前打开操作将成功返回；否则，可能阻塞直到有相应进程为读而打开该FIFO（当前打开操作设置了阻塞标志）；或者，返回ENXIO错误（当前打开操作没有设置阻塞标志）。

2.4有名管道的读写规则

从FIFO中读取数据：约定：如果一个进程为了从FIFO中读取数据而阻塞打开FIFO，那么称该进程内的读操作为设置了阻塞标志的读操作。

  • 如果有进程写打开FIFO，且当前FIFO内没有数据，则对于设置了阻塞标志的读操作来说，将一直阻塞。对于没有设置阻塞标志读操作来说则返回-1，当前errno值为EAGAIN，提醒以后再试。
  • 对于设置了阻塞标志的读操作说，造成阻塞的原因有两种：当前FIFO内有数据，但有其它进程在读这些数据；另外就是FIFO内没有数据。解阻塞的原因则是FIFO中有新的数据写入，不论信写入数据量的大小，也不论读操作请求多少数据量。
  • 读打开的阻塞标志只对本进程第一个读操作施加作用，如果本进程内有多个读操作序列，则在第一个读操作被唤醒并完成读操作后，其它将要执行的读操作将不再阻塞，即使在执行读操作时，FIFO中没有数据也一样（此时，读操作返回0）。
  • 如果没有进程写打开FIFO，则设置了阻塞标志的读操作会阻塞。

注：如果FIFO中有数据，则设置了阻塞标志的读操作不会因为FIFO中的字节数小于请求读的字节数而阻塞，此时，读操作会返回FIFO中现有的数据量。

向FIFO中写入数据：约定：如果一个进程为了向FIFO中写入数据而阻塞打开FIFO，那么称该进程内的写操作为设置了阻塞标志的写操作。

对于设置了阻塞标志的写操作：

  • 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳要写入的字节数时，才开始进行一次性写操作。
  • 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求写的数据后返回。

对于没有设置阻塞标志的写操作：

  • 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。
  • 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写；

对FIFO读写规则的验证：

下面提供了两个对FIFO的读写程序，适当调节程序中的很少地方或者程序的命令行参数就可以对各种FIFO读写规则进行验证。

程序1：写FIFO的程序

 1 #include
 2 #include
 3 #include
 4 #include
 5 #define FIFO_SERVER "/tmp/fifoserver"
 6 main(int argc,char** argv)
 7 //参数为即将写入的字节数
 8 {
 9     int fd;
10     char w_buf[4096*2];
11     int real_wnum;
12     memset(w_buf,0,4096*2);
13     if((mkfifo(FIFO_SERVER,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))
14         printf("cannot create fifoserver\n");
15     if(fd==-1)
16         if(errno==ENXIO)
17             printf("open error; no reading process\n");
18
19          fd=open(FIFO_SERVER,O_WRONLY|O_NONBLOCK,0);
20     //设置非阻塞标志
21     //fd=open(FIFO_SERVER,O_WRONLY,0);
22     //设置阻塞标志
23     real_wnum=write(fd,w_buf,2048);
24     if(real_wnum==-1)
25     {
26         if(errno==EAGAIN)
27             printf("write to fifo error; try later\n");
28     }
29     else
30         printf("real write num is %d\n",real_wnum);
31     real_wnum=write(fd,w_buf,5000);
32     //5000用于测试写入字节大于4096时的非原子性
33     //real_wnum=write(fd,w_buf,4096);
34     //4096用于测试写入字节不大于4096时的原子性
35
36     if(real_wnum==-1)
37         if(errno==EAGAIN)
38             printf("try later\n");
39 }

程序2：与程序1一起测试写FIFO的规则，第一个命令行参数是请求从FIFO读出的字节数

 1 #include
 2 #include
 3 #include
 4 #include
 5 #define FIFO_SERVER "/tmp/fifoserver"
 6 main(int argc,char** argv)
 7 {
 8     char r_buf[4096*2];
 9     int  fd;
10     int  r_size;
11     int  ret_size;
12     r_size=atoi(argv[1]);
13     printf("requred real read bytes %d\n",r_size);
14     memset(r_buf,0,sizeof(r_buf));
15     fd=open(FIFO_SERVER,O_RDONLY|O_NONBLOCK,0);
16     //fd=open(FIFO_SERVER,O_RDONLY,0);
17     //在此处可以把读程序编译成两个不同版本：阻塞版本及非阻塞版本
18     if(fd==-1)
19     {
20         printf("open %s for read error\n");
21         exit();
22     }
23     while(1)
24     {
25
26         memset(r_buf,0,sizeof(r_buf));
27         ret_size=read(fd,r_buf,r_size);
28         if(ret_size==-1)
29             if(errno==EAGAIN)
30                 printf("no data avlaible\n");
31         printf("real read bytes %d\n",ret_size);
32         sleep(1);
33     }
34     pause();
35     unlink(FIFO_SERVER);
36 }

程序应用说明：

把读程序编译成两个不同版本：

  • 阻塞读版本:br
  • 以及非阻塞读版本nbr

把写程序编译成两个四个版本：

  • 非阻塞且请求写的字节数大于PIPE_BUF版本：nbwg
  • 非阻塞且请求写的字节数不大于PIPE_BUF版本：版本nbw
  • 阻塞且请求写的字节数大于PIPE_BUF版本：bwg
  • 阻塞且请求写的字节数不大于PIPE_BUF版本：版本bw

下面将使用br、nbr、w代替相应程序中的阻塞读、非阻塞读

验证阻塞写操作：

  1. 当请求写入的数据量大于PIPE_BUF时的非原子性：

    • nbr 1000
    • bwg
  2. 当请求写入的数据量不大于PIPE_BUF时的原子性：
    • nbr 1000
    • bw

验证非阻塞写操作：

  1. 当请求写入的数据量大于PIPE_BUF时的非原子性：

    • nbr 1000
    • nbwg
  2. 请求写入的数据量不大于PIPE_BUF时的原子性：
    • nbr 1000
    • nbw

不管写打开的阻塞标志是否设置，在请求写入的字节数大于4096时，都不保证写入的原子性。但二者有本质区别：对于阻塞写来说，写操作在写满FIFO的空闲区域后，会一直等待，直到写完所有数据为止，请求写入的数据最终都会写入FIFO；而非阻塞写则在写满FIFO的空闲区域后，就返回(实际写入的字节数)，所以有些数据最终不能够写入。对于读操作的验证则比较简单，不再讨论。

小结

　　管道常用于两个方面：（1）在shell中时常会用到管道（作为输入输入的重定向），在这种应用方式下，管道的创建对于用户来说是透明的；（2）用于具有亲缘关系的进程间通信，用户自己创建管道，并完成读写操作。FIFO可以说是管道的推广，克服了管道无名字的限制，使得无亲缘关系的进程同样可以采用先进先出的通信机制进行通信。管道和FIFO的数据是字节流，应用程序之间必须事先确定特定的传输"协议"，采用传播具有特定意义的消息。要灵活应用管道及FIFO，理解它们的读写规则是关键。

附2：对FIFO打开规则的验证(主要验证写打开对读打开的依赖性)

 1 #include
 2 #include
 3 #include
 4 #include
 5 #define FIFO_SERVER "/tmp/fifoserver"
 6 int handle_client(char*);
 7 main(int argc,char** argv)
 8 {
 9     int r_rd;
10     int w_fd;
11     pid_t pid;
12     if((mkfifo(FIFO_SERVER,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))
13         printf("cannot create fifoserver\n");
14     handle_client(FIFO_SERVER);
15
16 }
17 int handle_client(char* arg)
18 {
19 int ret;
20 ret=w_open(arg);
21 switch(ret)
22 {
23     case 0:
24     {
25     printf("open %s error\n",arg);
26     printf("no process has the fifo open for reading\n");
27     return -1;
28     }
29     case -1:
30     {
31         printf("something wrong with open the fifo except for ENXIO");
32         return -1;
33     }
34     case 1:
35     {
36         printf("open server ok\n");
37         return 1;
38     }
39     default:
40     {
41         printf("w_no_r return ----\n");
42         return 0;
43     }
44 }
45 unlink(FIFO_SERVER);
46 }
47 int w_open(char*arg)
48 //0  open error for no reading
49 //-1 open error for other reasons
50 //1  open ok
51 {
52     if(open(arg,O_WRONLY|O_NONBLOCK,0)==-1)
53     {    if(errno==ENXIO)
54         {
55             return 0;
56         }
57         else
58         return -1;
59     }
60     return 1;
61
62 }

转自：http://blog.chinaunix.net/uid-11848011-id-96385.html

时间： 2024-10-12 13:25:14

Linux管道和命名管道的相关文章

进程间通信（1）---匿名管道与命名管道

管道是进程间通信一种基本的的一种方式,管道又分为两种,匿名管道和命名管道,先说匿名管道 匿名管道(pipe) #include <unistd.h> int pipe(int filedes[2]); 调用pipe时会在内核中开辟一个缓冲区,使用时fileds[0]为输出端,fileds[1]为写入端口,调用成功时返回0,失败时返回-1: pipe的特点: 1:它只能在有血缘关系的进程间进行通信. 2:它只能进行单项通信,一个进程读,另一个只能写. 3:它是一种流式服务. 4:它的生命周期跟随

Linux进程间通信 -- 使用命名管道

在前一篇文章—— Linux进程间通信 -- 使用匿名管道 中,我们看到了如何使用匿名管道来在进程之间传递数据,同时也看到了这个方式的一个缺陷,就是这些进程都由一个共同的祖先进程启动,这给我们在不相关的的进程之间交换数据带来了不方便.这里将会介绍进程的另一种通信方式——命名管道,来解决不相关进程间的通信问题. 一.什么是命名管道 命名管道也被称为FIFO文件,它是一种特殊类型的文件,它在文件系统中以文件名的形式存在,但是它的行为却和之前所讲的没有名字的管道(匿名管道)类似. 由于Linux中所有

Linux学习记录--命名管道通信

命名管道通信 什么是命名管道 一个主要的限制是,它是匿名管道的应用还没有名字,因此,只有它可以用于进程间通信的方式与亲缘关系.在命名管道(named pipe或FIFO)提出后,该限制得到了克服.FIFO不同于管道之处在于它提供一个路径名与之关联,以FIFO的文件形式存在于文件系统中. 这样,即使与FIFO的创建进程不存在亲缘关系的进程,仅仅要可以訪问该路径,就行彼此通过FIFO相互通信 有名管道创建 int mkfifo(const char * pathname, mode_t mode)

linux中的命名管道FIFO

匿名管道pipe前面已经说过了,接下来就说命名管道FIFO: 我们可以使用以下函数之一来创建一个命名管道,他们的原型如下:#include <sys/types.h>#include <sys/stat.h>int mkfifo(const char *filename, mode_t mode);int mknod(const char *filename, mode_t mode | S_IFIFO, (dev_t)0);这两个函数都能创建个FIFO,   注意是创建一个真实存

简述Linux进程间通信之命名管道FIFO

上文聊到管道(pipe),可以使有亲缘关系的进程间进行通信. 对于没有亲缘关系的进程如何通信?本文来聊一聊命名管道FIFO. 一.概念 命名管道FIFO,提供一个路径名与之关联,以文件形式存储于文件系统中. 一个进程以r方式打开,另一个程序以w方式打开,即可在两个进程之间建立管道. 通过以fifo文件作为媒介,可以使任意两个进程通过该文件进行通信. 命名管道(fifo)特性与管道(pipe)类似,不必赘述. 下面我们看FIFO如何进行进程间通信,首先来介绍一下所用到的函数: 二.函数原型 #in

linux中的命名管道（FIFO）

管道只能用于亲缘关系之间的通信,而FIFO中,只要可以访问路径,就可以进行通信. FIFO按照先进先出的原则进行通信,第一个被写入的数据首先从管道中读出. 创建命名管道的系统函数有两个: mknod和mkfifo.两个函数均定义在头文件sys/stat.h,函数原型如下: #include <sys/types.h>#include <sys/stat.h>int mknod(const char *path,mode_t mod,dev_t dev);int mkfifo(con

管道和命名管道

命名管道(named PIPE) 由于基于fork机制,所以管道只能用于父进程和子进程之间,或者拥有相同祖先的两个子进程之间 (有亲缘关系的进程之间).为了解决这一问题,Linux提供了FIFO方式连接进程.FIFO又叫做命名管道(named PIPE). FIFO (First in, First out)为一种特殊的文件类型,它在文件系统中有对应的路径.当一个进程以读(r)的方式打开该文件,而另一个进程以写(w)的方式打开该文件,那么内核就会在这两个进程之间建立管道,所以FIFO实际上也由内

Linus进程间通信（一）管道、命名管道的原理及实现

进程间通信 每个进程各自有不同额用户地址空间,任何一个进程的全局变量在另一个进程中多看不到,所以进程间要交换数据必须通过内核,在内核中开辟一段缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信(IPC,InterProcess Communication). 实现进程间通信的方式有:管道(pipe),命名管道(fifo),消息队列,信号量,共享内存... 管道 :是一种IPC机制,由pipe函数创建: #include <unistd.

linux进程通信之命名管道

前一节学习了无名管道,这节学习命名管道. 二命名管道 无名管道只能用来在父子进程或兄弟进程之间进行通信,这就给没有亲缘关系的进程之间数据的交换带来了麻烦,解决这个问题就是本节要学习的另一种管道通信:命名管道. 命名管道也被称为FIFO文件,FIFO不同于管道之处在于它提供一个路径名与之关联,以FIFO的文件形式存在于文件系统中.这样,即使与FIFO的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过FIFO相互通信(能够访问该路径的进程以及FIFO的创建进程之间),因此,通过FIF