#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());
}
结果是 [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
引用:原帖由 "naiza"]这里的if和else不是以前理解的选择分支。fork后产生的子进程和父进程并行运行的 发表:
这种理解是不正确的。if 和 else 还是选择分支。
主要的原因是,[color=red]fork() 函数调用一次,返回两次。[/color]两次返回的区别是:子进程的返回值是0,父进程返回值为新子进程的进程ID。
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
引用:原帖由 "ccf"]但是只有一个pid=fork(); 呀,fork()返回的第二次值在什么时候赋给pid呢 发表:
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
引用:原帖由 "lenovo" 发表: 它们已经是两个独立的进程了, 子进程怎么继承?
谢谢,就是说在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
引用:原帖由 "xhl" 发表: 我在父进程里定义的变量,子进程在创建的时候回自动创建一个副本,那如果我在子进程里,就是pid==0里创建的变量,父进程是不是看不到呢,
就是两个进程不共享数据段的情况下,父进程在创建子进程的之前的变量自进..........
你说的创建变量是什么意思?变量只能是静态的定义,fork是复制进程只要原进程里有的东西都会给复制出来(这里先不管共享不共享,对用户来说这是透明的你看不到哪里是复制的)。
hbczjzc 回复于:2004-05-07 13:20:32
编写进程条时很有用的哦.
corand 回复于:2004-05-09 13:03:25
fork后子进程跟父进程并行,公用程序段,若用vfork,则父进程被阻塞,等子进程执行完之后才会被执行
flw 回复于:2004-05-09 14:09:16
引用:原帖由 "sniper" 发表: 哦,偶明白了,在程序段里用了fork();之后程序出了分岔,派生出了两个进程。具体哪个先运行就看该系统的调度算法了。 在这里,我们可以这么认为,在运行到"pid=fork();"时系统派生出一个跟主程序一模一样的子进程。..........
完全正确。
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()); }
结果是 [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
引用:原帖由 "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是多少,都应该只有一行才对 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
引用:原帖由 "ohwww"]真是佩服各位,很受用 发表:
是呀
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
引用:原帖由 "mingjwan"]根据 chg.s的解释,请问,子进程在进行fork()操作的时候,是怎么知道自己就子进程,需要返回0,而不是继续产生一个子进程呢? 发表:
fork()产生子进程后,父子进程都执行fork()之后的语句,即子进程不再执行fork()语句。
郭子耳 回复于:2005-03-05 21:32:10
引用:原帖由 "chg.s"]操作系统创建一个新的进程(子进程),并且在进程表中相应为它建立一个新的表项。新进程和原有进程的可执行程序是同一个程序;上下文和数据,绝大部分就是原进程(父进程)的拷贝,但它们是两个相互独立的进程! 发表:
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]#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] [color=blue]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] 我觉得这样改写一下就更好理解了
THEBEST 回复于:2005-03-08 15:30:11
引用:原帖由 "sniper" 发表: 哦,偶明白了,在程序段里用了fork();之后程序出了分岔,派生出了两个进程。具体哪个先运行就看该系统的调度算法了。 在这里,我们可以这么认为,[color=red]在运行到"pid=fork();"时系统派生出一个跟主程序一模一样的子进程。该进程的 "pid=fork();"一句中pid得到的就是子进程本身的pid;子进程结束后,父进程的"pid=fork();"中pid得到的就是父进程本身 的pid。因此改程序有两行输出。 ..[/color] 本来也觉得各位讲的挺好的.但你这里说的不太懂,子进程一定先结束?如果系统调度是先执行父进程那它执行完了不就退出了?然后子进程还要执行.
该进程的"pid=fork();"一句中pid得到的就是子进程本身的pid;子进程结束后,父进程的"pid=fork();"中pid得到的就是父进程本身的pid
这是什么意思?怎么还分子进程和父进程的pid = fork()呢?
THEBEST 回复于:2005-03-08 15:38:51
引用:因为我们知道fork()向父进程返回了派生子进程的pid,是个正整数;而派生子进程的pid变量并没有被改变。这一区别使得我们看到了他们的不同输出。 派生子进程的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
引用:原帖由 "bashfulboy" 发表: 我也来一下: wujiajia 的理解有些错误, printf("AAAAAAAA");//print 一次; 这里会print 2次 如果你将 printf("AAAAAA") 换成 printf("AAAAAA/n") 那么就是只打印一次了. 主要的区别是因为有了一个 /n 回车..........
佩服,实在太强了!
icesummit 回复于:2005-03-08 23:03:55
佩服佩服。码这么多字已经是很不容易,何况还说的这么清楚呢?
lchhcllch 回复于:2005-03-09 09:35:51
都成FORK()专家了,贴出fork()实现代码就完结了.
wolf_xz 回复于:2005-09-30 17:37:01
我的理解是产生的新进程和父进程同样的代码,2个进程分时运行(可以理解为同时运行)所以2个都打印出来。(if 只是区别子和父进程 运行哪个代码)
daomeidan1234 回复于:2005-10-01 22:46:53
还是不明白,子进程的PID是4286,为什么是零呢?
trueno 回复于:2005-10-02 20:43:49
简单的说,
父子进程是从pid=fork(); 这条语句之后开始分开执行的。 1.父进程,由于成功创建了一个pid=4865的子进程,所以执行else 2.子进程,由于pid=0(初始值),所以执行then
注意: 子进程和父进程的pid 是完全不同的两个变量(虽然名字相同),父子进程要分别占用不同的资源的。 比如: int com=0; main() { int pid; pid=fork();
if(pid<0) then printf("error");
if(pid=0) then {com=1}; else {com=com+1}; printf{"com=%d/n",com};
} 最后的结果是什么呢? 应该是: com=1 com=1 .也就是说在父子进程里,全局变量com是两个不同的变量,占用的计算机资源是不同的。
menp9999 回复于:2005-10-04 13:22:00
引用:原帖由 "mingjwan"]根据 chg.s的解释,请问,子进程在进行fork()操作的时候,是怎么知道自己就子进程,需要返回0,而不是继续产生一个子进程呢? 发表:
紫京城不会再FORK的,除非你搞个循环,因为子京城是从FORK后面执行。
menp9999 回复于:2005-10-04 13:23:16
引用:原帖由 "lchhcllch"]都成FORK()专家了,贴出fork()实现代码就完结了. 发表:
看看LINUX啊,有的。
galaxywar 回复于:2005-10-04 18:05:06
引用:原帖由 "RedMarquis"]man了下,感觉还是做为个进程,另发现他的说明里推荐用exec,说什么会产生参数影响,不甚明白,盼楼上的能继续解释一下,谢谢 发表:
当进程调用一种e x e c函数时,该进程完全由新程序代换,而新程序则从其m a i n函数开始执行。 因为调用e x e c并不创建新进程,所以前后的进程I D并未改变。e x e c只是用另一个新程序替换了 当前进程的正文、数据、堆和栈段。
v f o r k用于创建一个新进程,而该新进程的目的是e x e c一个新程序 它并不将父进程的地址空间完全复制到子进程中,因为子进程会立即调用e x e c (或e x i t ),于 是也就不会存访该地址空间。不过在子进程调用e x e c或e x i t之前,它在父进程的空间中运行 v f o r k保证子进程先运行,在它调用e x e c或e x i t之后父进 程才可能被调度运行。(如果在调用这两个函数之前子进程依赖于父进程的进一步动作,则会 导致死锁。)
摘至《UNIX环境高级编程》
chinawang 回复于:2006-01-11 12:13:25
好,百看不厌
sdemon915 回复于:2006-01-11 17:35:12
子进程的PID不是0 根据fork的实现,fork的返回值可能为>0 =0 <0,3种情况 如果是>0说明是父进程,返回值是子进程的PID;如果是=0说明是子进程,子进程可以通过getpid()得到自己的PID,通过getppid得到父进程的PID;<0就说明fork失败
etflanker 回复于:2006-01-11 21:31:23
mark,学习ing!!
ChinaDream 回复于:2006-01-12 10:56:52
引用:原帖由 ccf 于 2004-4-23 11:23 发表 #include <unistd.h>;
#include <sys/types.h>;
main ()
{
pid_t pid;
pid=fork();
if (pid < 0)
printf("error in fork!") ...
老大,父进程在fork完之后会继续执行!子进程会得到父进在fork之前的所有数据复制并从fork之后执行!那两句其实是两个进程print出来和!不是一个进程!
jeromeecho 回复于:2006-03-31 14:23:56
这里的兄弟很让我感动.
sickcat2004 回复于:2006-04-01 17:11:01
引用:原帖由 bashfulboy 于 2004-7-14 22:10 发表
我也来一下:
wujiajia 的理解有些错误,
printf("AAAAAAAA");//print 一次; 这里会print 2次
如果你将 printf("AAAAAA") 换成 printf("AAAAAA/n") 那么就是只打印一次了.
...
豁然,开朗,啊哈哈哈!!1
~~~
fjingxu 回复于:2006-05-16 16:00:28
学到好多东西,顶!
sinoman 回复于:2006-05-16 17:58:42
引用:原帖由 bashfulboy 于 2004-7-14 22:10 发表
我也来一下:
wujiajia 的理解有些错误,
printf("AAAAAAAA");//print 一次; 这里会print 2次
如果你将 printf("AAAAAA") 换成 printf("AAAAAA/n") 那么就是只打印一次了.
...
是遇到"/n"是会fflush(stdout)吗?
printf("AAAAAAAA");
fflush(stdout);
应该没问题。
ketos 回复于:2006-05-16 22:26:16
受教!!
chenju2121 回复于:2006-05-17 15:29:53
fork()调用将会复制一个与当前进程几乎完全相同(除了fork的返回值不同)的新进程,这两个进程各有各的空间,各有各的局部变量,而且两个进程的局部变量的值在fork这个点处具有相等的值,只有fork返回的值不同,在该例子中,就是局部变量pid的值不同,新进程的pid变量为0,原来进程的pid为新进程的进程ID值。这样,两个并行的进程运行,才会出现你看到的结果。
windblood 回复于:2006-05-17 19:15:40
分析的不错
lichuxin9801 回复于:2006-06-26 11:23:18
嗯 说的不错 当初看的时候也是很迷惑的
epegasus 回复于:2006-06-26 11:33:32
我不知道可不可以这样理解,请高手指点:
当 fork()调用后
以下代码段:
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());
由被子进程和父进程都执行了,注意我把pid={fork()};中的fork()框起来了,因为只有“pid=”才是共同执行的部分。在fork()执行的时候PID被复制了一个。
xueyan 回复于:2006-06-26 21:24:01
#include <stdlib.h>
int main(int argc,char** argv)
{
int a;
int pid;
a=0;
pid = fork();
if(pid == 0)
{
a++;
}else
{
a--;
}
return 0;
}
disassem main
Dump of assembler code for function main:
0x08048368 <main+0>: push %ebp
0x08048369 <main+1>: mov %esp,%ebp
0x0804836b <main+3>: sub $0x8,%esp
0x0804836e <main+6>: and $0xfffffff0,%esp
0x08048371 <main+9>: mov $0x0,%eax
0x08048376 <main+14>: add $0xf,%eax
0x08048379 <main+17>: add $0xf,%eax
0x0804837c <main+20>: shr $0x4,%eax
0x0804837f <main+23>: shl $0x4,%eax
0x08048382 <main+26>: sub %eax,%esp
0x08048384 <main+28>: movl $0x0,0xfffffffc(%ebp)
0x0804838b <main+35>: [color=Red]call 0x80482a0[/color] //fork();从下一条指令开始,父子分道扬镳。操作系统通过复制父进程的相关信息创建子进程,父子共用一个代码段,但各有各的数据段。
0x08048390 <main+40>: mov %eax,0xfffffff8(%ebp) //将系统调用fork()的返回值存放到ebp,子进程的返回值是0,父进程为子进程的pid
0x08048393 <main+43>: cmpl $0x0,0xfffffff8(%ebp)//由于子进程的为零所以执行main+49
0x08048397 <main+47>: jne 0x80483a0 <main+56> //父进程为非零所以调到main+56
0x08048399 <main+49>: lea 0xfffffffc(%ebp),%eax
0x0804839c <main+52>: incl (%eax)
0x0804839e <main+54>: jmp 0x80483a5 <main+61>
0x080483a0 <main+56>: lea 0xfffffffc(%ebp),%eax
0x080483a3 <main+59>: decl (%eax)
0x080483a5 <main+61>: mov $0x0,%eax
0x080483aa <main+66>: leave
0x080483ab <main+67>: ret
End of assembler dump.
(gdb)
[ 本帖最后由 xueyan 于 2006-6-26 21:29 编辑 ]
okyzx 回复于:2006-07-27 14:56:48
好贴 学习
gankai1983 回复于:2006-07-28 21:34:27
简单的说就是子进程获取了父进程的数据段,具体哪些楼上说的很清楚了
|