fork()函数用法理解

 

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main()
{
pid_t pid;
static int n = 0;
printf(”fork!/n”); /*printf(”fork!”)*/
switch (pid = fork())
{
case -1:
{
/* 这里pid为-1，fork函数失败 */
/* 一些可能的原因是 */
/* 进程数或虚拟内存用尽 */
perror(”The fork failed!”);
break;
}
case 0:
{
/* pid为0，子进程 */
printf(”[child]i am child!/n”);
printf(”[child]getpid=[%d]/n”, getpid() );
printf(”[child]pid=[%d]/n”, pid );
break;
}
default:
{
/* pid大于0，父进程 */
printf(”[parent]i am parent!/n” );
printf(”[parent]getpid=[%d]/n”,getpid() );
printf(”[parent]pid=[%d]/n”,pid );
break;
}
}
printf(”n=[%d]/n”, n++);

return 0;
}

输出结果1
fork!
[child]i am child!
[child]getpid=[4807]
[child]pid=[0]
n=[0]
[parent]i am parent!
[parent]getpid=[4806]
[parent]pid=[4807]
n=[0]
输出结果2
fork![child]i am child!
[child]getpid=[6163]
[child]pid=[0]
n=[0]
fork![parent]i am parent!
[parent]getpid=[6162]
[parent]pid=[6163]
n=[0]

如果fork成功，子进程中fork的返回值是0，父进程中fork的返回值是子进程的进程号,getpid()返回的才是各自真实的进程号。

printf(”fork!”);//print 一次； 这里会print 2次
如果将 printf(”fork!”) 换成 printf(”fork!/n”) 那么就是只打印一次了.
主要的区别是因为有了一个 /n 回车符号
这就跟Printf的缓冲机制有关了,printf某些内容时,操作系统仅仅是把该内容放到了stdout的缓冲队列里了,并没有实际的写到屏幕上
但是,只要看到有 /n 则会立即刷新stdout,因此就马上能够打印了.
运行了printf(”fork!”) 后,fork!仅仅被放到了缓冲里,再运行到fork时,缓冲里面的fork!被子进程继承了
因此在子进程度stdout缓冲里面就也有了fork!.
所以,你最终看到的会是fork!被printf了2次!!!!
而运行 printf(”fork!/n”)后,fork!被立即打印到了屏幕上,之后fork到的子进程里的stdout缓冲里不会有 AAAAAA 内容
因此你看到的结果会是 AAAAAA 被printf了1次!!!!

一段关于fork的小程序的启示

前几天，论坛上有人问了这样一个问题：
#include <sys/types.h>
#include <unistd.h>

int main()
{
for(int i= 0; i<3; i++)
{
int pid= fork();
if(pid== 0)
{
printf(“child/n”);
}
else
{
printf(“father/n”);
}
}
return 0;
}

请问输出结果是什么？

初看，想当然认为结果是3对child-father，只是顺序不确定，而且按照Unix环境高级编程中的说法，极端的情况下可能还会出现两个输出的内容相互夹杂的情况。

但是，在Unix测试了一下发现输出竟然有7对child-father。为什么会这样呢？看了半天程序终于明白了这个简单的问题。其实，这个问题在写/懂汇编的人看来是再清楚不过了，问题就出在这个for循环。
1.i=0时，父进程进入for循环，此时由于fork的作用，产生父子两个进程(分别记为F0/S0)，分别输出father和child，然后，二者分别执行后续的代码，那后续的代码是什么呢?return 0?当然不是，由于for循环的存在，后续的代码是add指令和一条jump指令，因此，父子进程都将进入i=1的情况；
2.i=1时，父进程继续分成父子两个进程(分别记为F1/S1)，而i=0时fork出的子进程也将分成两个进程(分别记为FS01/SS01)，然后所有这些进程进入i=2；
3.….过程于上面类似，已经不用多说了，相信一切都已经明了了，依照上面的标记方法，i=2时将产生F2/S2,FS12/SS12,FFS012/SFS012,FSS012/SSS012.
因此，最终的结果是输出7对child/father。其对应的数学公式为：
1+ 2+ 4+ … + 2^(n- 1) = 2^n- 1

不过话说回来，这种在for循环中使用fork的作法实在不值得推荐，研究研究尚可，实际应用恐怕会引来很多麻烦，需小心谨慎才是。