这里先看两个例子：
1) 源码如下：
1 #include <sys/types.h> 2 3 #include <stdio.h> 4 5 #include <stdlib.h> 6 7 #include <unistd.h> 8 9 #include <errno.h> 10 11 12 13 int main(int argc, char *argv[]) 14 15 { 16 17 pid_t pid; 18 19 20 21 fprintf (stderr, "this is stderr string! "); 22 23 printf ("this is stdout string! "); 24 25 26 27 if ((pid = fork()) == 0) 28 29 { 30 31 32 33 } 34 35 else if (pid > 0) 36 37 { 38 39 40 41 } 42 43 else 44 45 { 46 47 fprintf (stderr, "fork error! errno: %d errstr: %s ", errno, strerror(errno)); 48 49 } 50 51 52 53 exit(0); 54 55 }
运行：
问：这里printf ("this is stdout string!
");为什么会在文件中打印两句出来？而在不重定向的情况下只打印一次；
2) 这是一个进程间的pipe通信，代码如下：
1 // main_process.c 2 3 #include <sys/types.h> 4 5 #include <stdio.h> 6 7 #include <stdlib.h> 8 9 #include <unistd.h> 10 11 12 13 int main(int argc, char *argv[]) 14 15 { 16 17 int pipe_fd[2]; 18 19 pid_t pid; 20 21 char pipe_buf[1024]; 22 23 int ret; 24 25 26 27 if (pipe(pipe_fd) < 0) 28 29 fprintf(stderr, "pipe failed! "); 30 31 32 33 if ((pid = fork()) == 0) /* child */ 34 35 { 36 37 close(pipe_fd[0]); 38 39 dup2(pipe_fd[1], STDOUT_FILENO); 40 41 close(pipe_fd[1]); 42 43 if (execl("./child_process", "./child_process", NULL) == -1) 44 45 fprintf (stderr, "execl faild! "); 46 47 exit(0); 48 49 } 50 51 else if (pid > 0) /* parent */ 52 53 { 54 55 close(pipe_fd[1]); 56 57 while ((ret = read(pipe_fd[0], pipe_buf, sizeof(pipe_buf) - 1)) > 0) 58 59 { 60 61 pipe_buf[ret] = ' '; 62 63 printf ("%s ", pipe_buf); 64 65 fflush(stdout); 66 67 } 68 69 close(pipe_fd[0]); 70 71 } 72 73 else 74 75 fprintf (stderr, "fork failed! "); 76 77 78 79 exit(0); 80 81 } 82 83 84 85 // child_process.c 86 87 #include <sys/types.h> 88 89 #include <stdio.h> 90 91 #include <stdlib.h> 92 93 #include <unistd.h> 94 95 96 97 int main(int argc, char *argv[]) 98 99 { 100 101 int i; 102 103 104 105 for (i=0; i<100; i++) 106 107 { 108 109 printf ("counter: %d ", i); 110 111 sleep(1); 112 113 } 114 115 116 117 exit(0); 118 119 }
我们的原意是将child进程的输出重定向，然后从main进程中接收并打印出来，根据程序也就是1s打印一次计数，但这个程序在运行中会出现什么问题呢？main进程的read会一直阻塞，直到child进程将pipe_fd[1]写满以后才会有返回打印出。
其实，这两个问题都源于一个原因，那就是缓冲的原因。
在输入输出的缓冲中，我们知道有三种：无缓冲、行缓冲和块缓冲（也叫全缓冲）。
对于标准输出/标准错误输出，默认的缓冲方式是：标准错误输出是无缓冲输出，也就是只要给stderr写数据，马上就会送出；标准输出分两种情况，如果输出定向的是到设备终端（tty），那么是行缓冲，如果是其他设备/文件，则是块缓冲。
这就可以解释上面两种情况了：
1) 但重定向到文件输出时，printf的内容会在缓冲中，fork时会将当前的缓冲区clone一个，而且内容不变，但进程结束的时候，系统会自动flush缓冲区，所以子进程和服进程均将缓冲区的内容输出，所以出现了两次同样的printf的内容；
2) 主进程将子进程的stdout重定向到pipe输出，所以child就会块缓冲，所以并不是每秒去flush一下buffer，而是当buffer满或者child进程关闭时flush，故main进程的read就不是我们的原意了。
弄清楚了原因，解决这个问题也有两种方法：
1) 在printf后，使用fflush(stdout)手动flush缓冲区；
2) 使用setbuf或setvbuf设置stdout的缓冲方式；
小结：
由于stdout 在定向的位置不一样会有不一样的缓冲方式，所以在写被调用的子进程的时候一定要注意这个问题，最好在使用stdout的地方使用fflush进行手动flush。