程序博客网 > vb简易计算器代码

问题：子进程父进程哪个先执行：【转】关于 fork 和父子进程的理解 + 【转】

来源：互联网 发布：vb简易计算器代码 编辑：程序博客网 时间：2024/04/27 21:34

关于 fork 和父子进程的理解   （http://blog.163.com/kingore@126/blog/static/8540871920097300284862/）

代码:#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 
-------------------------------------------------------------
Q: 我就想不到为什么两行都打印出来了，在我想来，不管pid是多少，都应该只有一行才对

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

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

A: pid这个变量是有两个的， 父进程一个， 子进程一个。

---------------------------------------------------------------

要搞清楚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... 

我想你比较困惑的就是，为什么看上去程序中互斥的两个分支都被执行了。在一个程序的一次执行中，这当然是不可能的；但是你看到的两行输出是来自两个进程，这两个进程来自同一个程序的两次执行。 

我的天，不知道说明白了没……

--------------------------------------------------------------------------------

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

-------------------------------------------------------------------------------

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




****************************************************************************************************************************

linux中fork函数及子进程父进程进程先后（http://blog.csdn.net/wu_zf/article/details/7640970）

一、fork入门知识

     一个进程，包括代码、数据和分配给进程的资源。fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。
    一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。相当于克隆了一个自己。

     我们来看一个例子：

[cpp] view plaincopy
  1. /* 
  2.  *  fork_test.c 
  3.  *  version 1 
  4.  *  Created on: 2010-5-29 
  5.  *      Author: wangth 
  6.  */  
  7. #include <unistd.h>  
  8. #include <stdio.h>   
  9. int main ()   
  10. {   
  11.     pid_t fpid; //fpid表示fork函数返回的值  
  12.     int count=0;  
  13.     fpid=fork();   
  14.     if (fpid < 0)   
  15.         printf("error in fork!");   
  16.     else if (fpid == 0) {  
  17.         printf("i am the child process, my process id is %d/n",getpid());   
  18.         printf("我是爹的儿子/n");//对某些人来说中文看着更直白。  
  19.         count++;  
  20.     }  
  21.     else {  
  22.         printf("i am the parent process, my process id is %d/n",getpid());   
  23.         printf("我是孩子他爹/n");  
  24.         count++;  
  25.     }  
  26.     printf("统计结果是: %d/n",count);  
  27.     return 0;  
  28. }  

     运行结果是：
    i am the child process, my process id is 5574
    我是爹的儿子
    统计结果是: 1
    i am the parent process, my process id is 5573
    我是孩子他爹
    统计结果是: 1
    在语句fpid=fork()之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了，这两个进程的几乎完全相同，将要执行的下一条语句都是if(fpid<0)……
    为什么两个进程的fpid不同呢，这与fork函数的特性有关。fork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值：
    1）在父进程中，fork返回新创建子进程的进程ID；
    2）在子进程中，fork返回0；
    3）如果出现错误，fork返回一个负值；

    在fork函数执行完毕后，如果创建新进程成功，则出现两个进程，一个是子进程，一个是父进程。在子进程中，fork函数返回0，在父进程中，fork返回新创建子进程的进程ID。我们可以通过fork返回的值来判断当前进程是子进程还是父进程。

    引用一位网友的话来解释fpid的值为什么在父子进程中不同。“其实就相当于链表，进程形成了链表，父进程的fpid(p 意味point)指向子进程的进程id, 因为子进程没有子进程，所以其fpid为0.
    fork出错可能有两种原因：
    1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。
    2）系统内存不足，这时errno的值被设置为ENOMEM。
    创建新进程成功后，系统中出现两个基本完全相同的进程，这两个进程执行没有固定的先后顺序，哪个进程先执行要看系统的进程调度策略。
    每个进程都有一个独特（互不相同）的进程标识符（process ID），可以通过getpid（）函数获得，还有一个记录父进程pid的变量，可以通过getppid（）函数获得变量的值。
    fork执行完毕后，出现两个进程，

    有人说两个进程的内容完全一样啊，怎么打印的结果不一样啊，那是因为判断条件的原因，上面列举的只是进程的代码和指令，还有变量啊。
    执行完fork后，进程1的变量为count=0，fpid！=0（父进程）。进程2的变量为count=0，fpid=0（子进程），这两个进程的变量都是独立的，存在不同的地址中，不是共用的，这点要注意。可以说，我们就是通过fpid来识别和操作父子进程的。
    还有人可能疑惑为什么不是从#include处开始复制代码的，这是因为fork是把进程当前的情况拷贝一份，执行fork时，进程已经执行完了int count=0;fork只拷贝下一个要执行的代码到新的进程。

二、fork进阶知识

    先看一份代码：

[cpp] view plaincopy
  1. /* 
  2.  *  fork_test.c 
  3.  *  version 2 
  4.  *  Created on: 2010-5-29 
  5.  *      Author: wangth 
  6.  */  
  7. #include <unistd.h>  
  8. #include <stdio.h>  
  9. int main(void)  
  10. {  
  11.    int i=0;  
  12.    printf("i son/pa ppid pid  fpid/n");  
  13.    //ppid指当前进程的父进程pid  
  14.    //pid指当前进程的pid,  
  15.    //fpid指fork返回给当前进程的值  
  16.    for(i=0;i<2;i++){  
  17.        pid_t fpid=fork();  
  18.        if(fpid==0)  
  19.            printf("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
  20.        else  
  21.            printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
  22.    }  
  23.    return 0;  
  24. }  

    运行结果是：
    i son/pa ppid pid  fpid
    0 parent 2043 3224 3225
    0 child  3224 3225    0
    1 parent 2043 3224 3226
    1 parent 3224 3225 3227
    1 child     1 3227    0
    1 child     1 3226    0 
    这份代码比较有意思，我们来认真分析一下：
    第一步：在父进程中，指令执行到for循环中，i=0，接着执行fork，fork执行完后，系统中出现两个进程，分别是p3224和p3225（后面我都用pxxxx表示进程id为xxxx的进程）。可以看到父进程p3224的父进程是p2043，子进程p3225的父进程正好是p3224。我们用一个链表来表示这个关系：
    p2043->p3224->p3225 
    第一次fork后，p3224（父进程）的变量为i=0，fpid=3225（fork函数在父进程中返向子进程id），代码内容为：

[c-sharp] view plaincopy
  1. for(i=0;i<2;i++){  
  2.     pid_t fpid=fork();//执行完毕，i=0，fpid=3225  
  3.     if(fpid==0)  
  4.        printf("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
  5.     else  
  6.        printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
  7. }  
  8. return 0;  

    p3225（子进程）的变量为i=0，fpid=0（fork函数在子进程中返回0），代码内容为：

[c-sharp] view plaincopy
  1. for(i=0;i<2;i++){  
  2.     pid_t fpid=fork();//执行完毕，i=0，fpid=0  
  3.     if(fpid==0)  
  4.        printf("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
  5.     else  
  6.        printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
  7. }  
  8. return 0;  

    所以打印出结果：
    0 parent 2043 3224 3225
    0 child  3224 3225    0
    第二步：假设父进程p3224先执行，当进入下一个循环时，i=1，接着执行fork，系统中又新增一个进程p3226，对于此时的父进程，p2043->p3224（当前进程）->p3226（被创建的子进程）。
    对于子进程p3225，执行完第一次循环后，i=1，接着执行fork，系统中新增一个进程p3227，对于此进程，p3224->p3225（当前进程）->p3227（被创建的子进程）。从输出可以看到p3225原来是p3224的子进程，现在变成p3227的父进程。父子是相对的，这个大家应该容易理解。只要当前进程执行了fork，该进程就变成了父进程了，就打印出了parent。
    所以打印出结果是：
    1 parent 2043 3224 3226
    1 parent 3224 3225 3227 
    第三步：第二步创建了两个进程p3226，p3227，这两个进程执行完printf函数后就结束了，因为这两个进程无法进入第三次循环，无法fork，该执行return 0;了，其他进程也是如此。
    以下是p3226，p3227打印出的结果：
    1 child     1 3227    0
    1 child     1 3226    0 
    细心的读者可能注意到p3226，p3227的父进程难道不该是p3224和p3225吗，怎么会是1呢？这里得讲到进程的创建和死亡的过程，在p3224和p3225执行完第二个循环后，main函数就该退出了，也即进程该死亡了，因为它已经做完所有事情了。p3224和p3225死亡后，p3226，p3227就没有父进程了，这在操作系统是不被允许的，所以p3226，p3227的父进程就被置为p1了，p1是永远不会死亡的，至于为什么，这里先不介绍，留到“三、fork高阶知识”讲。
    总结一下，这个程序执行的流程如下：

     这个程序最终产生了3个子进程，执行过6次printf（）函数。
    我们再来看一份代码：

[cpp] view plaincopy
  1. /* 
  2.  *  fork_test.c 
  3.  *  version 3 
  4.  *  Created on: 2010-5-29 
  5.  *      Author: wangth 
  6.  */  
  7. #include <unistd.h>  
  8. #include <stdio.h>  
  9. int main(void)  
  10. {  
  11.    int i=0;  
  12.    for(i=0;i<3;i++){  
  13.        pid_t fpid=fork();  
  14.        if(fpid==0)  
  15.            printf("son/n");  
  16.        else  
  17.            printf("father/n");  
  18.    }  
  19.    return 0;  
  20.   
  21. }  

     它的执行结果是：
    father
    son
    father
    father
    father
    father
    son
    son
    father
    son
    son
    son
    father
    son 
    这里就不做详细解释了，只做一个大概的分析。
    for        i=0         1           2
              father     father     father
                                        son
                            son       father
                                        son
               son       father     father
                                        son
                            son       father
                                        son
    其中每一行分别代表一个进程的运行打印结果。
    总结一下规律，对于这种N次循环的情况，执行printf函数的次数为2*（1+2+4+……+2N-1）次，创建的子进程数为1+2+4+……+2N-1个。(感谢gao_jiawei网友指出的错误，原本我的结论是“执行printf函数的次数为2*（1+2+4+……+2N）次，创建的子进程数为1+2+4+……+2N ”，这是错的)
    网上有人说N次循环产生2*（1+2+4+……+2N）个进程，这个说法是不对的，希望大家需要注意。

    数学推理见http://202.117.3.13/wordpress/?p=81（该博文的最后）。
    同时，大家如果想测一下一个程序中到底创建了几个子进程，最好的方法就是调用printf函数打印该进程的pid，也即调用printf("%d/n",getpid());或者通过printf("+/n");来判断产生了几个进程。有人想通过调用printf("+");来统计创建了几个进程，这是不妥当的。具体原因我来分析。
    老规矩，大家看一下下面的代码：

[cpp] view plaincopy
  1. /* 
  2.  *  fork_test.c 
  3.  *  version 4 
  4.  *  Created on: 2010-5-29 
  5.  *      Author: wangth 
  6.  */  
  7. #include <unistd.h>  
  8. #include <stdio.h>  
  9. int main() {  
  10.     pid_t fpid;//fpid表示fork函数返回的值  
  11.     //printf("fork!");  
  12.     printf("fork!/n");  
  13.     fpid = fork();  
  14.     if (fpid < 0)  
  15.         printf("error in fork!");  
  16.     else if (fpid == 0)  
  17.         printf("I am the child process, my process id is %d/n", getpid());  
  18.     else  
  19.         printf("I am the parent process, my process id is %d/n", getpid());  
  20.     return 0;  
  21. }  

    执行结果如下：
    fork!
    I am the parent process, my process id is 3361
    I am the child process, my process id is 3362 
    如果把语句printf("fork!/n");注释掉，执行printf("fork!");
    则新的程序的执行结果是：
    fork!I am the parent process, my process id is 3298
    fork!I am the child process, my process id is 3299 
    程序的唯一的区别就在于一个/n回车符号，为什么结果会相差这么大呢？
    这就跟printf的缓冲机制有关了，printf某些内容时，操作系统仅仅是把该内容放到了stdout的缓冲队列里了,并没有实际的写到屏幕上。但是,只要看到有/n 则会立即刷新stdout,因此就马上能够打印了。
    运行了printf("fork!")后,“fork!”仅仅被放到了缓冲里,程序运行到fork时缓冲里面的“fork!”  被子进程复制过去了。因此在子进程度stdout缓冲里面就也有了fork! 。所以,你最终看到的会是fork!  被printf了2次！！！！
    而运行printf("fork! /n")后,“fork!”被立即打印到了屏幕上,之后fork到的子进程里的stdout缓冲里不会有fork! 内容。因此你看到的结果会是fork! 被printf了1次！！！！
    所以说printf("+");不能正确地反应进程的数量。
    大家看了这么多可能有点疲倦吧，不过我还得贴最后一份代码来进一步分析fork函数。

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <unistd.h>  
  3. int main(int argc, char* argv[])  
  4. {  
  5.    fork();  
  6.    fork() && fork() || fork();  
  7.    fork();  
  8.    return 0;  
  9. }  

    问题是不算main这个进程自身，程序到底创建了多少个进程。
    为了解答这个问题，我们先做一下弊，先用程序验证一下，到此有多少个进程。

[c-sharp] view plaincopy
  1. #include <stdio.h>  
  2. int main(int argc, char* argv[])  
  3. {  
  4.    fork();  
  5.    fork() && fork() || fork();  
  6.    fork();  
  7.    printf("+/n");  
  8. }  

    答案是总共20个进程，除去main进程，还有19个进程。
    我们再来仔细分析一下，为什么是还有19个进程。
    第一个fork和最后一个fork肯定是会执行的。
    主要在中间3个fork上，可以画一个图进行描述。
    这里就需要注意&&和||运算符。
    A&&B，如果A=0，就没有必要继续执行&&B了；A非0，就需要继续执行&&B。
    A||B，如果A非0，就没有必要继续执行||B了，A=0，就需要继续执行||B。
    fork()对于父进程和子进程的返回值是不同的，按照上面的A&&B和A||B的分支进行画图，可以得出5个分支。

    

     加上前面的fork和最后的fork，总共4*5=20个进程，除去main主进程，就是19个进程了。

三、fork高阶知识

        这一块我主要就fork函数讲一下操作系统进程的创建、死亡和调度等。因为时间和精力限制，我先写到这里，下次找个时间我争取把剩下的内容补齐。

参考资料：

 

      http://blog.csdn.net/dog_in_yellow/archive/2008/01/13/2041079.aspx

      http://blog.chinaunix.net/u1/53053/showart_425189.html

      http://blog.csdn.net/saturnbj/archive/2009/06/19/4282639.aspx

      http://www.cppblog.com/zhangxu/archive/2007/12/02/37640.html

      http://www.qqread.com/linux/2010/03/y491043.html

      http://www.yuanma.org/data/2009/1103/article_3998.htm



2 0
vb简易计算器代码 vb简易计算器代码
原创粉丝点击
热门IT博客
淘宝cf得抽奖在那抽的淘宝cf得抽奖在那抽的
淘宝整蛊零食店铺推荐淘宝整蛊零食店铺推荐
上海磁记录数据恢复
sql两个表关联查询
性能最好的php框架
网络名言名句大全爱情
淘宝助理导入手机详情
淘宝卖的玛咖是真是假
hr如何面试java程序员
相似度矩阵 聚类算法
淘宝店开好后怎么做
mill9.1编程教程清角
网络婚姻的好处和坏处
云南民歌 污 知乎
html5实战源码
农业重金属 知乎
网络诈骗的手段有
分水岭算法基本原理
java构造方法特点
手机发票制作软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 对白搞硬沙发午睡的儿子 客厅沙发儿子碎花裙 电影客厅午睡的母亲 客厅午睡以为你是爸爸 客厅弄醒午唾的儿子 客厅搞硬午睡的儿子小说 客厅弄醒穿花裙子午睡的妈电影 在客厅里弄醒午睡的儿子 中午弄醒正在午睡中的护校小 客厅弄醒午睡的妈视频完整迅雷 弄醒客厅午睡花裙子母亲 对白弄醒午睡的儿子 客厅沙发午睡的妈 母亲今晚让你入个够 在客厅里弄醒午睡的 客厅里午睡的花裙子电影 睡在客厅午睡的母亲 客厅弄醒午睡的妈视频 ckm 客厅中弄醒午睡的儿子 艹醒客厅上睡觉的百褶裙 搞硬午睡儿子沙发大战视频 客厅弄醒午睡的在线播放 在客厅穿花裙子午睡的母亲视频 艹客厅沙发午睡 中国小叔子强大嫂 强睡大嫂风间游美 原千岁老公原谅 美人未亡夫原千岁 原千岁在播放 电影让兄弟睡自己老婆 兄弟的老婆3电影 原千岁宠溺儿在线播放 强睡大搜中女主是谁 给男朋友兄弟口 趁老婆喝醉睡着上闺蜜电影 楼上干兄弟老婆 楼下兄弟打牌 强睡年轻女老板韩国 睡兄弟老婆电微电影 喝醉了睡了兄弟女朋友 强睡大搜中文字黑夜 年轻的女老板2中文字

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里