请大家来讨论下popen在协同进程方面的怪异行为（我已经实验过了）

wawxdyy

LInux中pipe只能支持单向通道，而popen实际上就是将(pipe,fork,exec)这三步简化成一步，但是我一开始产生了一个误区，问题在协同进程这，我们都知道，协同进程可以用两个单向管道来构造，我一开始认为用两个popen也可以达到同样的功能，但在理论上这是行不通的，因为，用两个pipe的方法只创建一个子进程（协同进程）；而用两次popen会产生两个子进程（两次fork），所以这两种方法的区别应该如下图：

所以说按道理popen的方法是应该不能起到协同进程的作用的，可是结果呢，它同样能很好的运行，下面是两种方法的代码，用过滤程序的功能是从输入得到两个整数，然后输出二者之和：
方法1：pipe

1. 
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <errno.h>
   
7. #include <signal.h>
   
8. #include <fcntl.h>
   
9. 
   
10. #define MAX_LINE        2048
    
11. 
    
12. static void sig_pipe(int);
    
13. 
    
14. int
    
15. main(void)
    
16. {
    
17.         int        n, fd1[2], fd2[2];
    
18.         char        line[MAX_LINE];
    
19.         pid_t        pid;
    
20.        
    
21.         if (signal(SIGPIPE, sig_pipe) == SIG_ERR) {
    
22.                 printf("init signal error: %s\n", strerror(errno));
    
23.                 exit(1);
    
24.         }
    
25.        
    
26.         if ((pipe(fd1) < 0) || (pipe(fd2) < 0)) {
    
27.                 printf("create pipe error: %s\n", strerror(errno));
    
28.                 exit(1);
    
29.         }
    
30.        
    
31.         if ((pid = fork()) < 0) {
    
32.                 printf("fork error: %s\n", strerror(errno));
    
33.                 exit(1);
    
34.         } else if (pid > 0) {
    
35.                 close(fd1[0]);
    
36.                 close(fd2[1]);
    
37.                 while (fgets(line, MAX_LINE, stdin) != NULL) {
    
38.                         n = strlen(line);
    
39.                         if (write(fd1[1], line, n) != n) {
    
40.                                 printf("write to pipe failed: %s\n", strerror(errno));
    
41.                                 exit(1);
    
42.                         }
    
43.                        
    
44.                         if ((n = read(fd2[0], line, MAX_LINE)) < 0) {
    
45.                                 printf("read from pipe failed: %s\n", strerror(errno));
    
46.                                 exit(1);
    
47.                         }
    
48.                        
    
49.                         if (n == 0) {
    
50.                                 printf("child closed pipe\n");
    
51.                                 break;
    
52.                         }
    
53.                        
    
54.                         line[n] = 0;
    
55.                         if (fputs(line, stdout) == EOF) {
    
56.                                 printf("fputs error: %s\n", strerror(errno));
    
57.                                 exit(1);
    
58.                         }
    
59.                 }
    
60.                 if (ferror(stdin)) {
    
61.                         printf("fgets error: %s\n", strerror(errno));
    
62.                         exit(1);
    
63.                 }
    
64.         } else {
    
65.                 close(fd1[1]);
    
66.                 close(fd2[0]);
    
67.                
    
68.                 if (fd1[0] != STDIN_FILENO) {
    
69.                         if (dup2(fd1[0], STDIN_FILENO) != STDIN_FILENO) {
    
70.                                 printf("dup2 error: %s\n", strerror(errno));
    
71.                                 exit(1);
    
72.                         }
    
73.                         close(fd1[0]);
    
74.                 }
    
75.                
    
76.                 if (fd2[1] != STDOUT_FILENO) {
    
77.                         if (dup2(fd2[1], STDOUT_FILENO) != STDOUT_FILENO) {
    
78.                                 printf("dup2 error: %s\n", strerror(errno));
    
79.                                 exit(1);
    
80.                         }
    
81.                         close(fd2[1]);
    
82.                 }
    
83.                
    
84.                 if (execl("./add2", "add2", (char *)0) < 0) {
    
85.                         printf("execl error: %s\n", strerror(errno));
    
86.                         exit(1);
    
87.                 }
    
88.         }
    
89.        
    
90.         exit(0);
    
91. }
    
92. 
    
93. static void
    
94. sig_pipe(int signo)
    
95. {
    
96.         printf("SIG_PIPE caught\n");
    
97.         exit(1);
    
98. }
    

复制代码

方法2：popen

1. 
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <errno.h>
   
7. #include <signal.h>
   
8. #include <fcntl.h>
   
9. 
   
10. #define MAX_LINE        2048
    
11. 
    
12. static void sig_pipe(int);
    
13. 
    
14. int
    
15. main(void)
    
16. {
    
17.         int        n, fd[2];
    
18.         char        line[MAX_LINE];
    
19.         pid_t        pid;
    
20.         FILE        *fpin, *fpout;
    
21.        
    
22.         if (signal(SIGPIPE, sig_pipe) == SIG_ERR) {
    
23.                 printf("init signal error: %s\n", strerror(errno));
    
24.                 exit(1);
    
25.         }
    
26.        
    
27.         if ((fpout = popen("./add2", "w")) == NULL) {
    
28.                 printf("popen error: %s\n", strerror(errno));
    
29.                 exit(1);
    
30.         }
    
31.        
    
32.         if ((fpin = popen("./add2", "r")) == NULL) {
    
33.                 printf("popen error: %s\n", strerror(errno));
    
34.                 exit(1);
    
35.         }
    
36.        
    
37.         while (fgets(line, MAX_LINE, stdin) != NULL) {
    
38.                 n = strlen(line);
    
39.                 fd[0] = fileno(fpout);
    
40.                 if (write(fd[0], line, n) != n) {
    
41.                         printf("write to pipe failed: %s\n", strerror(errno));
    
42.                         exit(1);
    
43.                 }
    
44.                 fd[1] = fileno(fpin);
    
45.                 if ((n = read(fd[1], line, MAX_LINE)) < 0) {
    
46.                         printf("read from pipe failed: %s\n", strerror(errno));
    
47.                         exit(1);
    
48.                 } else if (n == 0) {
    
49.                         printf("child closed pipe\n");
    
50.                         break;
    
51.                 } else {
    
52.                         line[n] = 0;
    
53.                         if (fputs(line, stdout) == EOF) {
    
54.                                 printf("fputs error: %s\n", strerror(errno));
    
55.                                 exit(1);
    
56.                         }
    
57.                 }
    
58.         }
    
59.         if (ferror(stdin)) {
    
60.                 printf("fgets error: %s\n", strerror(errno));
    
61.                 exit(1);
    
62.         }
    
63.         exit(0);
    
64. }
    
65. 
    
66. static void
    
67. sig_pipe(int signo)
    
68. {
    
69.         printf("SIG_PIPE caught\n");
    
70.         exit(1);
    
71. }
    

复制代码

过滤程序：

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <string.h>
   
6. #include <errno.h>
   
7. 
   
8. #define        MAX_LINE        2048
   
9. 
   
10. int
    
11. main(void)
    
12. {
    
13.         int        n, int1, int2;
    
14.         char        line[MAX_LINE];
    
15.        
    
16.         while ((n = read(STDIN_FILENO, line, MAX_LINE)) > 0) {
    
17.                 if (sscanf(line, "%d%d", &int1, &int2) == 2) {
    
18.                         sprintf(line, "%d\n", int1 + int2);
    
19.                         n = strlen(line);
    
20.                         if (write(STDOUT_FILENO, line, n) != n) {
    
21.                                 printf("write error: %s", strerror(errno));
    
22.                                 exit(1);
    
23.                         }
    
24.                 } else {
    
25.                         if (write(STDOUT_FILENO, "Invalid args\n", 13) != 13) {
    
26.                                 printf("write error: %s", strerror(errno));
    
27.                                 exit(1);
    
28.                         }
    
29.                 }
    
30.         }
    
31.         exit(0);
    
32. }
    

复制代码

这两种方法都可以运行，效果一样，而且在用popen方法的时候，ps一下会看到确实有两个add2子进程，现在问题出来了，为什么popen这种方法也能正常工作呢，小弟刚开始学unix编程不久，还请各位兄弟多来发表一下自己的看法

Dasn

Post by wawxdyy

这两种方法都可以运行，效果一样，而且在用popen方法的时候，ps一下会看到确实有两个add2子进程，现在问题出来了，为什么popen这种方法也能正常工作呢

两个add2 进程之间没有联系，它们各自的I/O扰乱了楼主的判断。lz 可以考虑在主程序的输出中加一个标记：

1. 
   
2. $ diff -u popen.c.orig popen.c                                             
   
3. --- popen.c.orig  Mon Jun 18 07:31:16 2007
   
4. +++ popen.c     Mon Jun 18 07:35:53 2007
   
5. @@ -15,7 +15,7 @@
   
6. {
   
7.         int     n,  fd[2];
   
8.         char    line[MAX_LINE];
   
9. -       pid_t   pid;
   
10. +       /* pid_t        pid; */
    
11.         FILE    *fpin,  *fpout;
    
12.         
    
13.         if (signal(SIGPIPE,  sig_pipe) == SIG_ERR) {
    
14. @@ -49,7 +49,8 @@
    
15.                         break;
    
16.                 } else {
    
17.                         line[n] = 0;
    
18. -                       if (fputs(line,  stdout) == EOF) {
    
19. +                       char tmp[MAX_LINE + 6] = "OUT-> ";
    
20. +                       if (fputs(strncat(tmp, line, n),  stdout) == EOF) {
    
21.                                 printf("fputs error: %s\n",  strerror(errno));
    
22.                                 exit(1);
    
23.                         }
    

复制代码

wawxdyy

恩，是Ù样，谢谢阿