fork的一个例子，好像人家是讲得很详细了，我还是不明白

[code:1:896e04449a]#include <unistd.h>
#include <sys/types.h>

main ()
{
        pid_t pid;
        pid=fork();

        if (pid < 0)
                printf("error in fork!");
        else if (pid == 0)
                printf("i am the child process, my process id is %d\n",getpid());
        else
                printf("i am the parent process, my process id is %d\n",getpid());
}[/code:1:896e04449a]

结果是
[root@localhost c]# ./a.out
i am the child process, my process id is 4286
i am the parent process, my process id is 4285


我就想不到为什么两行都打印出来了，在我想来，不管pid是多少，都应该只有一行才对

naiza 回复于：2004-04-23 11:38:11

这里的if和else不是以前理解的选择分支。fork后产生的子进程和父进程并行运行的

sashow 回复于：2004-04-23 13:41:16

[quote:7b2607dafc="naiza"]这里的if和else不是以前理解的选择分支。fork后产生的子进程和父进程并行运行的[/quote:7b2607dafc] 这种理解是不正确的。if 和 else 还是选择分支。 主要的原因是，[color=red:7b2607dafc]fork() 函数调用一次，返回两次。[/color:7b2607dafc]两次返回的区别是：子进程的返回值是0，父进程返回值为新子进程的进程ID。

clearcase/" target="_blank" >ccf 回复于：2004-04-23 14:38:59

但是只有一个pid=fork(); 呀，fork()返回的第二次值在什么时候赋给pid呢

victory7 回复于：2004-04-27 18:06:29

这是由系统来控制fork地返回的

davidtian 回复于：2004-04-27 18:11:20

fork后，父子进程共用程序段

birdielu 回复于：2004-04-27 18:56:54

恩, 分析的很精辟

lenovo 回复于：2004-04-27 20:09:20

[quote:d347015cc8="ccf"]但是只有一个pid=fork(); 呀，fork()返回的第二次值在什么时候赋给pid呢[/quote:d347015cc8] pid这个变量是有两个的， 父进程一个， 子进程一个。

chg.s 回复于：2004-04-27 21:09:30

要搞清楚fork的执行过程，就必须先讲清楚操作系统中的“进程(process)”概念。一个进程，主要包含三个元素： o. 一个可以执行的程序； o. 和该进程相关联的全部数据（包括变量，内存空间，缓冲区等等）； o. 程序的执行上下文（execution context）。 不妨简单理解为，一个进程表示的，就是一个可执行程序的一次执行过程中的一个状态。操作系统对进程的管理，典型的情况，是通过进程表完成的。进程表中的每一个表项，记录的是当前操作系统中一个进程的情况。对于单 CPU的情况而言，每一特定时刻只有一个进程占用 CPU，但是系统中可能同时存在多个活动的（等待执行或继续执行的）进程。 一个称为“程序计数器（program counter, pc）”的寄存器，指出当前占用 CPU的进程要执行的下一条指令的位置。 当分给某个进程的 CPU时间已经用完，操作系统将该进程相关的寄存器的值，保存到该进程在进程表中对应的表项里面；把将要接替这个进程占用 CPU的那个进程的上下文，从进程表中读出，并更新相应的寄存器（这个过程称为“上下文交换(process context switch)”，实际的上下文交换需要涉及到更多的数据，那和fork无关，不再多说，主要要记住程序寄存器pc指出程序当前已经执行到哪里，是进程上下文的重要内容，换出 CPU的进程要保存这个寄存器的值，换入CPU的进程，也要根据进程表中保存的本进程执行上下文信息，更新这个寄存器）。 好了，有这些概念打底，可以说fork了。当你的程序执行到下面的语句： pid=fork();  操作系统创建一个新的进程（子进程），并且在进程表中相应为它建立一个新的表项。新进程和原有进程的可执行程序是同一个程序；上下文和数据，绝大部分就是原进程（父进程）的拷贝，但它们是两个相互独立的进程！此时程序寄存器pc，在父、子进程的上下文中都声称，这个进程目前执行到fork调用即将返回（此时子进程不占有CPU，子进程的pc不是真正保存在寄存器中，而是作为进程上下文保存在进程表中的对应表项内）。问题是怎么返回，在父子进程中就分道扬镳。 父进程继续执行，操作系统对fork的实现，使这个调用在父进程中返回刚刚创建的子进程的pid（一个正整数），所以下面的if语句中pid<0, pid==0的两个分支都不会执行。所以输出i am the parent process... 子进程在之后的某个时候得到调度，它的上下文被换入，占据 CPU，操作系统对fork的实现，使得子进程中fork调用返回0。所以在这个进程（注意这不是父进程了哦，虽然是同一个程序，但是这是同一个程序的另外一次执行，在操作系统中这次执行是由另外一个进程表示的，从执行的角度说和父进程相互独立）中pid=0。这个进程继续执行的过程中，if语句中pid<0不满足，但是pid==0是true。所以输出i am the child process... 我想你比较困惑的就是，为什么看上去程序中互斥的两个分支都被执行了。在一个程序的一次执行中，这当然是不可能的；但是你看到的两行输出是来自两个进程，这两个进程来自同一个程序的两次执行。 我的天，不知道说明白了没……

UNIX大瓜 回复于：2004-04-27 23:14:44

精辟

Zalophus 回复于：2004-04-28 03:30:44

问题是，结果显示是子进程先打印出自己的pid的，是不是子进程先于父进程执行了？

chg.s 回复于：2004-04-28 09:16:31

到底哪个进程执行在先，这个和操作系统的调度算法等等很多因素相关。我觉得理解上的困难，关键在于为什么会有两个输出，而不是谁先谁后。

zhaojinbo 回复于：2004-04-28 12:35:50

fork之后，操作系统会复制一个与父进程完全相同的子进程，虽说是父子关系，但是在操作系统看来，他们更像兄弟关系，这2个进程共享代码空间，但是数据空间是互相独立的，子进程数据空间中的内容是父进程的完整拷贝，指令指针也完全相同，但只有一点不同，如果fork成功，子进程中fork的返回值是0，父进程中fork的返回值是子进程的进程号，如果fork不成功，父进程会返回错误。 可以这样想象，2个进程一直同时运行，而且步调一致，在fork之后，他们分别作不同的工作，也就是分岔了。这也是fork为什么叫fork的原因。 至于那一个最先运行，可能与操作系统有关，而且这个问题在实际应用中并不重要，如果需要父子进程协同，可以通过原语的办法解决。

luoting 回复于：2004-04-28 15:45:08

清晰！感谢！

ccf 回复于：2004-04-28 17:06:59

明白了,thanks a lot

carol1980 回复于：2004-04-28 17:15:21

:D 获益匪浅

xhl 回复于：2004-04-28 17:21:44

我在父进程里定义的变量，子进程在创建的时候回自动创建一个副本，那如果我在子进程里，就是pid==0里创建的变量，父进程是不是看不到呢， 就是两个进程不共享数据段的情况下，父进程在创建子进程的之前的变量自进程都能继承，但要是父进程在fork后创建的变量，子进程能继承吗？？？

lenovo 回复于：2004-04-28 17:25:43

它们已经是两个独立的进程了， 子进程怎么继承？

xhl 回复于：2004-04-28 17:42:06

[quote:315e2dd628="lenovo"]它们已经是两个独立的进程了， 子进程怎么继承？[/quote:315e2dd628] 谢谢，就是说在fork前父进程的东西子进程可以继承，而在fork后子进程没有任何和父进程的继承关系了。在子进程里创建的东西是子进程的，在父进程创建的东西是父进程的。可以完全看成两个进程。

lenovo 回复于：2004-04-28 19:46:49

对。

sniper 回复于：2004-04-28 22:11:15

哦，偶明白了，在程序段里用了fork();之后程序出了分岔，派生出了两个进程。具体哪个先运行就看该系统的调度算法了。 在这里，我们可以这么认为，在运行到"pid=fork();"时系统派生出一个跟主程序一模一样的子进程。该进程的"pid=fork();"一句中pid得到的就是子进程本身的pid；子进程结束后，父进程的"pid=fork();"中pid得到的就是父进程本身的pid。因此改程序有两行输出。

henngy 回复于：2004-04-29 10:13:32

fock关键要控制的是谁先返回！是子进程还是父进程，，用wait控制！

xangyu 回复于：2004-04-29 11:58:03

真的很不错!谢谢!!

adccpeng 回复于：2004-04-30 14:12:13

获益非浅！！ 辛苦！

playmud 回复于：2004-05-06 14:08:29

有这么麻烦吗？一个进程打印一句话。

bierdaci 回复于：2004-05-06 21:14:51

[quote:3f8c8aaf17="xhl"]我在父进程里定义的变量，子进程在创建的时候回自动创建一个副本，那如果我在子进程里，就是pid==0里创建的变量，父进程是不是看不到呢， 就是两个进程不共享数据段的情况下，父进程在创建子进程的之前的变量自进..........[/quote:3f8c8aaf17] 你说的创建变量是什么意思？变量只能是静态的定义，fork是复制进程只要原进程里有的东西都会给复制出来（这里先不管共享不共享，对用户来说这是透明的你看不到哪里是复制的）。

hbczjzc 回复于：2004-05-07 13:20:32

编写进程条时很有用的哦.

corand 回复于：2004-05-09 13:03:25

fork后子进程跟父进程并行,公用程序段,若用vfork,则父进程被阻塞,等子进程执行完之后才会被执行

flw 回复于：2004-05-09 14:09:16

[quote:df58bdf128="sniper"]哦，偶明白了，在程序段里用了fork();之后程序出了分岔，派生出了两个进程。具体哪个先运行就看该系统的调度算法了。 在这里，我们可以这么认为，在运行到"pid=fork();"时系统派生出一个跟主程序一模一样的子进程。..........[/quote:df58bdf128] 完全正确。

sniper 回复于：2004-05-10 10:53:44

补充一下，fork()函数复制了当前进程的PCB，并向父进程返回了派生子进程的pid。而且根据上面“corand”兄的提示，父子进程并行，打印语句的先后完全看系统的调度算法。打印的内容控制则靠pid变量来控制。因为我们知道fork()向父进程返回了派生子进程的pid，是个正整数；而派生子进程的pid变量并没有被改变。这一区别使得我们看到了他们的不同输出。

jjl3 回复于：2004-07-14 11:43:20

我做如下修改 #include <unistd.h>  #include <sys/types.h>  main ()  {          pid_t pid;          printf("fork!");    // printf("fork!\n");         pid=fork();          if (pid < 0)                  printf("error in fork!");          else if (pid == 0)                  printf("i am the child process, my process id is %d\n",getpid());          else                  printf("i am the parent process, my process id is %d\n",getpid());  }[/code:1:896e04449a]  结果是  [root@localhost c]# ./a.out  fork!i am the child process, my process id is 4286  fork!i am the parent process, my process id is 4285 但我改成printf("fork!\n");后，结果是 [root@localhost c]# ./a.out fork!  i am the child process, my process id is 4286  i am the parent process, my process id is 4285 为什么只有一个fork!打印出来了？上一个为什么有2个？

lenovo 回复于：2004-07-14 13:48:33

看这个： http://bbs.chinaunix.net/forum/viewtopic.php?t=244249&highlight=蓝色键盘

RedMarquis 回复于：2004-07-14 16:03:04

搭车问一个弱问题：  if(fork()==0)     system("cat test.c");   这样是不是会产生2个进程？分别是子进程和cat？

lenovo 回复于：2004-07-14 16:32:16

man system

RedMarquis 回复于：2004-07-14 17:10:48

man了下，感觉还是做为个进程，另发现他的说明里推荐用exec，说什么会产生参数影响，不甚明白，盼楼上的能继续解释一下，谢谢

默难 回复于：2004-07-14 20:41:12

[quote:1257475361="ccf"]alhost c]# ./a.out i am the child process, my process id is 4286 i am the parent process, my process id is 4285 我就想不到为什么两行都打印出来了，在我想来，不管pid是多少，都应该只有一行才对[/quote:1257475361]fork返回值是两个，一个返回给父进程（子进程的ID）一个返回给子进程（0）

wujiajia 回复于：2004-07-14 21:30:59

main() { int a; int pid; printf("AAAAAAAA");//print 一次； pid=fork();//重这里开始分为两个 if(pid==0){//在这里定义的变量父进程是不会有的:int b; printf("ok");} else if(pid>0){ printf("is ok\n");//if you want print b;error!but you can print a; } printf("BBBBBBB");//父子进程都会打印; } 不知道我的回答是否正确！

bashfulboy 回复于：2004-07-14 22:10:52

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

ohwww 回复于：2004-07-17 10:19:22

真是佩服各位,很受用

eagerly1 回复于：2004-07-17 21:51:18

[quote:48b27e4789="ohwww"]真是佩服各位,很受用[/quote:48b27e4789] 是呀

jjl3 回复于：2004-07-19 15:19:30

:)

mingjwan 回复于：2004-08-19 10:46:50

根据 chg.s的解释,请问,子进程在进行fork()操作的时候,是怎么知道自己就子进程,需要返回0,而不是继续产生一个子进程呢?

bjldlee 回复于：2004-09-05 21:26:45

to bashfulboy: main()  {  int a;  int pid;  printf("AAAAAAAA");//print 两次；  pid=fork();//重这里开始分为两个,但是子进程也会执行这个语句!!!这就产生了悖论!!!  if(pid==0){//在这里定义的变量父进程是不会有的:int b;  printf("ok");}  else if(pid>0){  printf("is ok\n");//if you want print b;error!but you can print a;  }  printf("BBBBBBB");//父子进程都会打印;  }

temin 回复于：2004-10-15 09:20:29

收益，顶

xhl0902 回复于：2004-10-15 09:51:24

讲的够清楚，够明了。佩服佩服

zerglot 回复于：2004-10-15 15:57:59

了解了!haha

cnufo 回复于：2005-01-10 00:56:01

3x,perfect!

xujunxp 回复于：2005-01-10 19:57:31

顶，收获颇多

superroy 回复于：2005-01-11 14:53:33

[quote:de928d087a="mingjwan"]根据 chg.s的解释,请问,子进程在进行fork()操作的时候,是怎么知道自己就子进程,需要返回0,而不是继续产生一个子进程呢?[/quote:de928d087a] fork()产生子进程后，父子进程都执行fork()之后的语句，即子进程不再执行fork()语句。

郭子耳 回复于：2005-03-05 21:32:10

[quote:8d5e48213c="chg.s"]操作系统创建一个新的进程（子进程），并且在进程表中相应为它建立一个新的表项。新进程和原有进程的可执行程序是同一个程序；上下文和数据，绝大部分就是原进程（父进程）的拷贝，但它们是两个相互独立的进程！[/quote:8d5e48213c]

zlrll 回复于：2005-03-05 22:37:10

其实可以理解为fork就是生成了当前进程的一个副本，与原来进程不同的是原来进程中返回的是>0，副本中返回＝＝0，两个进程各执行一次if（），所以会打印2个了

hmilyhacker 回复于：2005-03-06 07:49:16

谢谢各位大大，受益匪浅

lss888 回复于：2005-03-06 20:53:53

[color=red:3819baa262]#include <unistd.h> #include <sys/types.h> main () {       int i=5;         pid_t pid;         pid=fork();         for(;i>0;i--){         if (pid < 0)                 printf("error in fork!");         else if (pid == 0)                 printf("i am the child process, my process id is %d and i=%d\n",getpid(),i);         else                 printf("i am the parent process, my process id is %d and i=%d\n",getpid(),i);           } }[/color:3819baa262] [color=blue:3819baa262]i am the child process, my process id is 11879 and i=5 i am the child process, my process id is 11879 and i=4 i am the child process, my process id is 11879 and i=3 i am the child process, my process id is 11879 and i=2 i am the child process, my process id is 11879 and i=1 i am the parent process, my process id is 11878 and i=5 i am the parent process, my process id is 11878 and i=4 i am the parent process, my process id is 11878 and i=3 i am the parent process, my process id is 11878 and i=2 i am the parent process, my process id is 11878 and i=1[/color:3819baa262] 我觉得这样改写一下就更好理解了

THEBEST 回复于：2005-03-08 15:30:11

[quote:d26e599e6d="sniper"]哦，偶明白了，在程序段里用了fork();之后程序出了分岔，派生出了两个进程。具体哪个先运行就看该系统的调度算法了。 在这里，我们可以这么认为，[color=red:d26e599e6d]在运行到"pid=fork();"时系统派生出一个跟主程序一模一样的子进程。该进程的"pid=fork();"一句中pid得到的就是子进程本身的pid；子进程结束后，父进程的"pid=fork();"中pid得到的就是父进程本身的pid。因此改程序有两行输出。 ..[/color:d26e599e6d][/quote:d26e599e6d]本来也觉得各位讲的挺好的.但你这里说的不太懂,子进程一定先结束?如果系统调度是先执行父进程那它执行完了不就退出了?然后子进程还要执行. 该进程的"pid=fork();"一句中pid得到的就是子进程本身的pid；子进程结束后，父进程的"pid=fork();"中pid得到的就是父进程本身的pid 这是什么意思?怎么还分子进程和父进程的pid = fork()呢?

THEBEST 回复于：2005-03-08 15:38:51

[quote:5a0826e8f0]因为我们知道fork()向父进程返回了派生子进程的pid，是个正整数；而派生子进程的pid变量并没有被改变。这一区别使得我们看到了他们的不同输出。[/quote:5a0826e8f0]派生子进程的pid变量并没有被改变是什么意思?对于子进程来讲pid不就是0吗?

albcamus 回复于：2005-03-08 15:56:11

>>派生子进程的pid变量并没有被改变是什么意思?对于子进程来讲pid不就是0吗? 1,派生子进程的进程，即父进程，其pid不变； 2,对子进程来说，fork返回给它0,但它的pid绝对不会是0；之所以fork返回0给它，是因为它随时可以调用getpid()来获取自己的pid； 3,楼上的楼上的你的观点是对的，fork之后夫子进程除非采用了同步手段，否则不能确定谁先运行，也不能确定谁先结束。认为子进程结束后父进程才从fork返回的，这是不对的，fork不是这样的，vfork才这样。

zlrll 回复于：2005-03-08 20:37:17

[quote:c891178d6b="bashfulboy"]我也来一下: wujiajia 的理解有些错误, printf("AAAAAAAA");//print 一次；   这里会print 2次 如果你将 printf("AAAAAA") 换成 printf("AAAAAA\n")   那么就是只打印一次了. 主要的区别是因为有了一个 \n  回车..........[/quote:c891178d6b] 佩服，实在太强了！

icesummit 回复于：2005-03-08 23:03:55

佩服佩服。码这么多字已经是很不容易，何况还说的这么清楚呢？

lchhcllch 回复于：2005-03-09 09:35:51

都成FORK()专家了,贴出fork()实现代码就完结了.

原文转自：http://www.ltesting.net

评论列表（网友评论仅供网友表达个人看法，并不表明本站同意其观点或证实其描述）