fork_forkvfork - CSDN
精华内容
参与话题
  • 操作系统fork()进程

    万次阅读 多人点赞 2019-03-01 11:57:11
    1、fork()是创建进程函数。 2、c程序一开始,就会产生 一个进程,当这个进程执行到fork()的时候,会创建一个子进程。 3、此时父进程和子进程是共存的,它们俩会一起向下执行c程序的代码。 4、需要注意!!!子...

    1、fork()是创建进程函数。

    2、c程序一开始,就会产生 一个进程,当这个进程执行到fork()的时候,会创建一个子进程。

    3、此时父进程和子进程是共存的,它们俩会一起向下执行c程序的代码。

    4、需要注意!!!子进程创建成功后,fork是返回两个值,一个代表父进程,一个代表子进程:代表父进程的值是一串数字,这串数字是子进程的ID(地址);一个代表子进程,值为0。

    下面写一段代了解了解(注释很重要)
    在这里插入图片描述
    运行结果如下父进程printf出来的是子进程 的ID即那串数字,子进程printf的则为0:
    在这里插入图片描述

    深入学习

    1-1.c

    #include<unistd.h>
    #include<stdio.h>
    int main()
    {
            int p1,p2;
            if(p1=fork())               /*子进程创建成功*/
                    //父进程返回的是一串数字>1,满足条件,执行下面语句
               putchar('b');//首先输出b,之后该父进程自杀了(结束)
            else   //这里是由于子进程的fork为0,子进程在这里面执行
            {
                    if(p2=fork())       //在这里子进程创建了自己的子进程(先凑合叫做孙进程吧),此时子进程fork返回孙进程的ID>1,则可以执行下面语句
                       putchar('c');//子进程执行,输出c
                    else
                       putchar('a');           /*父进程执行*/
    		//上面老师注释的父进程我认为是“孙进程”,而不是一开始的父进程,一开始的父进程putchar出b后,已经被杀死了,不信可以 printf("%d",p2);,看看是不是输出0,fork()为0,则为孙进程
            }
    printf("\n");
    
    }
    

    执行结果(注意看代码注释,通俗点说就是父进程输出了b,子进程输出了c,孙进程输出a 。其实没有孙进程这种说法吧。)
    在这里插入图片描述

    1-2.c

    #include<stdio.h> 
    #include<sys/types.h>
    #include<unistd.h> 
    int main() 
    {  
        int p1,p2;  
        while((p1=fork())==-1)//如果子进程创建失败则fork返回-1=-1,while循环不会跳出,直至创建成功,fork为子进程的ID或者0才可以跳出while循环
    	printf("111");  //没有输出111.说明p1不等于-1,那说明子进程创建成功,直接跳出while循环
           // printf("%d\n",p1);     //父子进程都会执行这一句,谁先谁后是随机的,所以有可能先显示0再显示ID,否则反之
        if (p1==0)               //子进程的fork为0,满足此条件            
          putchar('b'); 	     //由子进程输出‘b’,接着子进程自杀
        else 		     //由于刚刚父进程不满足上面的if条件,所以来到else这下面执行
        {  
          while((p2=fork())==-1);  //重建子进程(第二个孩子)
          if (p2==0)             //第二个孩子满足fork=0  
           putchar('c'); 		//第二个孩子执行输出“c”
          else                   //父进程最终什么都不满足地来到这里
           {putchar('a');  	     //父进程输出“a”
    	//printf("\n%d\n",p2);
    	}
        } 
    }//结果我猜正确的顺序是acb或者bac。这个要看父子进程的看快慢,就像赛跑。
    
    

    执行结果
    在这里插入图片描述

    2-1.c

    #include<stdio.h>
    #include<unistd.h>
    int main()
    {
    	int p1,p2,i;
    	if(p1=fork())//此时父进程的fork为一串数字,子进程fork为0;父进程的fork>0,满足条件
     		for(i=0;i<5;i++)
    		        printf("child %d\n",i);//说明创建进程成功,不管是男孩还是女孩
    	else//子进程不满足上面if条件,从而来到这里
    	{ 
     	if(p2=fork())//子进程来这里创建“孙”进程,此后子进程fork为一串数字即“孙”进程的ID;则孙进程的fork为0;子进程fork>0,满足条件
        		for(i=0;i<5;i++) 
    			printf("son %d\n",i);
     	else//“孙”进程不满足上面if条件,从而来到这里
        		for(i=0;i<5;i++)  
    			printf("daughter %d\n",i);//老师的理解和我的不一样吧。我认为这是子进程的子进程了,是个女儿。
    	}
    }
    
    //输出结果的话,也是随机的
    
    

    执行结果:
    在这里插入图片描述
    2-2.c

    /*
    author:Szymou
    explain:
    lockf(1,1,0)是锁上资源让该进程独自享用
    lockf(1,0,0)是解锁资源,给其他进程用
    下面的sleep用于该进程“休息一下”,休息的时候,其他进程可以用资源
    这里的资源是个人认为是磁盘的缓冲区buffer
    */
    #include<stdio.h>
    #include<unistd.h>
    int main()//每次printf的时候,系统会先将需要输出的字符存在缓冲区buffer里面
    {
    	int p1,p2,i;
    	if(p1=fork())
    	{
         	lockf(1,1,0);//锁上buffer自己享用
         	for(i=0;i<3;i++)  
    		{
    		printf("child %d\n",i);
    		/*老师的默认第二个lockf(1,1,0)是一直锁上的,结果会是先全部输出son012,再输出其他,其他进程同理*/
         	lockf(1,0,0);//解锁给另外的子进程  
         	sleep(2);//其他子进程可以在父进程休眠的时候调用buffer使用
         	}
    	}
    	else
     	{
      		if(p2=fork())
    			{ 
    			    lockf(1,1,0);//锁上buffer自己享用
         			for(i=0;i<3;i++)  
         			{
         			printf("son %d\n",i);
        			lockf(1,0,0);
        			sleep(2);
        			}
      			}
    		else
    		{ 
    		    lockf(1,1,0);//锁上buffer自己享用     //运行结果>>>>>
         		for(i=0;i<3;i++)                    //运行结果>>>>>
         		{
         		printf("daughter %d\n",i);
       	 	    lockf(1,0,0);
       	 	    sleep(2);
       	 	    }
    		}
    	 }return 0;
    }
    
    

    运行结果:
    在这里插入图片描述
    3-1.c

    /*
    author:Szymou
    explain:
    父进程称为a进程
    往下就是b、c、d进程
    */
    #include<stdio.h>
    #include<unistd.h>
    int main()
     {
        int p1,p2,p3,p4;
        while((p1=fork())==-1);//a进程在这里创建b进程
    
        if(p1!=0)//父进程称为a进程,进来了
        {
         	printf("process a(its id=%d,its father pid is %d)\n",getpid(),getppid());
        }
        else//b进程进来了
        {
            printf("precess b(its id=%d,its father pid is %d)\n",getpid(),getppid());
            while((p2=fork())==-1) ;//b进程创建c进程
    
            if(p2==0)//c进程进来
            {
                printf("precess c(its id=%d,its father pid is %d)\n",getpid(),getppid());
                while((p3=fork())==-1) ;//c进程创建d进程
    
                if(p3==0)//d进程进来
                printf("precess d(its id=%d,its father pid is %d)\n",getpid(),getppid());
           }
        }
    return 0;
    }
    
    

    观察执行结果,会发现有些进程的父进程ID显示不是自己父进程的ID 这是因为其父进程死了,而她成了孤儿进程,被某进程收养了,所以显示的父进程ID是收养它的那个进程的ID,可以用命令ps
    x查看当前进程,查找进程ID,即可明了。
    在这里插入图片描述

    应该怎么使得每个进程的父进程ID显示正确呢?
    那就应该让该父进程别死,让它等待其子进程死后再死即可。这时候我们就应该使用一个函数了,这个函数是wait()。
    作用是父进程执行到wait(),会被挂起来,等待其子进程结束后,自己才结束。

    代码:

    /*
    author:Szymou
    explain:
    父进程称为a进程
    往下就是b、c、d进程;
    有一种情况:有些进程显示其父进程ID不是父进程ID,而是系统进程ID,这是因为父进程死后,子进程get不到父进程ID,从而成了孤儿,在乌班图下会被upstart收养,在CentOS下会被init收养。可以用ps x来查看;
    wait()函数可以让当前父进程等待子进程结束,父进程才结束。这里引进这个函数,是因为,避免父进程死后,子进程没了爸爸,找不到爸爸的ID即getppid
    */
    
    /*
        这两个头文件用于支持wait()函数
    */
    #include <sys/types.h> 
    #include <sys/wait.h>
    
    
    #include<stdio.h>
    #include<unistd.h>
    int main()
     {
        int p1,p2,p3,p4;
        while((p1=fork())==-1);//a进程在这里创建b进程
        if(p1!=0)//父进程称为a进程,进来了
        {
         	printf("process a(its id=%d,its father pid is %d)\n",getpid(),getppid());
         	wait(NULL);
        }
        else//b进程进来了
        {
            printf("precess b(its id=%d,its father pid is %d)\n",getpid(),getppid());
            while((p2=fork())==-1) ;//b进程创建c进程
            if(p2!=0) wait(NULL);
    	//sleep(1);
            else if(p2==0)//c进程进来
            {
                printf("precess c(its id=%d,its father pid is %d)\n",getpid(),getppid());
                while((p3=fork())==-1) ;//c进程创建d进程
                if(p3!=0) wait(NULL);
    	    //sleep(1);
                else if(p3==0)//d进程进来
                printf("precess d(its id=%d,its father pid is %d)\n",getpid(),getppid());
           }
        }
    return 0;
    }
    
    

    运行结果(不再会出现孤儿进程现象)
    在这里插入图片描述

    有什么问题可以在评论区一起讨论哦!一起学

    展开全文
  • linux中fork()函数详解(原创!!实例讲解)

    万次阅读 多人点赞 2011-06-15 23:53:00
    一、fork入门知识 二、fork进阶知识 三、fork高阶知识

     一、fork入门知识

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

         我们来看一个例子:

         运行结果是:
        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进阶知识

        先看一份代码:

        运行结果是:
        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),代码内容为:

        p3225(子进程)的变量为i=0,fpid=0(fork函数在子进程中返回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()函数。
        我们再来看一份代码:

         它的执行结果是:
        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("+");来统计创建了几个进程,这是不妥当的。具体原因我来分析。
        老规矩,大家看一下下面的代码:

        执行结果如下:
        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函数。

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

        答案是总共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

    展开全文
  • Linux中fork()函数详解

    万次阅读 多人点赞 2018-08-12 04:42:38
    linux中fork()函数详解    一、fork入门知识  一个进程,包括代码、数据和分配给进程的资源。fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程, 也就是两个进程可以做完全相同的事,但如果...

     

    linux中fork()函数详解

     

     一、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/jason314/article/details/5640969

     

    展开全文
  • fork()介绍

    万次阅读 2018-06-27 20:54:32
    fork()函数: 用于创建一个进程,所创建的进程复制父进程的代码段/数据段/BSS段/堆/栈等所有用户空间信息;在内核中操作系统重新为其申请了一个PCB,并使用父进程的PCB进行初始化; 子进程执行的位置是fork()函数...

    fork()函数:
    用于创建一个进程,所创建的进程复制父进程的代码段/数据段/BSS段/堆/栈等所有用户空间信息;在内核中操作系统重新为其申请了一个PCB,并使用父进程的PCB进行初始化;
    子进程执行的位置是fork()函数执行后的代码处,猜想是复制了父进程的PC指针给子进程。

    例题:

    #include "stdio.h"
    #include "sys/types.h"
    #include "unistd.h"
    
    int main()
    {
        pid_t pid1;
        pid_t pid2;
    
        pid1 = fork();
        pid2 = fork();
    
        printf("pid1:%d, pid2:%d\n", pid1, pid2);
    }

    要求如下:
    已知从这个程序执行到这个程序的所有进程结束这个时间段内,没有其它新进程执行。

      1、请说出执行这个程序后,将一共运行几个进程。
    
      2、如果其中一个进程的输出结果是“pid1:1001, pid2:1002”,写出其他进程的输出结果(不考虑进程执行顺序)。
    

    1/假设父进程(main所在的进程)为P0,经两次fork()函数,会创建它的2个子进程P1/P2;子进程P1创建后,从fork()执行后的代码处开始执行,即执行代码段

    pid1:1001, pid2:1002
    pid1:0, pid2:1002
    pid1:1001, pid2:0
    pid1:0, pid2:0

    fork()具体步骤如下:
    第一阶段:打开目标映像文件

    第二阶段:创建内核中的进程对象

    第三阶段:创建初始线程

    第四阶段:通知windows子系统进程csrss.exe进程来对新进程进行管理

    第五阶段:启动初始线程

    第六阶段:用户空间的初始化和Dll连接

    具体内容:

    在Windows中,CreateProcess要先通过系统调用NtCreateProcess创建进程,成功以后就立即通过系统调用NtCreateThread创建其第一个线程。

    第一阶段:打开目标映像文件

    首先用CreateProcess(实际上是CreateProcessW)打开指定的可执行映像文件,并创建一个内存区对象。注意,内存区对象并没有被映射到内存中(由于目标进程尚未建立起来,不可能完成内存映射),但它确实是打开了。

    第二阶段:创建内核中的进程对象

    实际上就是创建以EPROCESS为核心的相关数据结构,主要包括:

    调用内核中的NtCreateProcessEx 系统服务,实际的调用过程是这样的:kernel32.dll 中的CreateProcessW调用ntdll.dll 中的存根函数NtCreateProcessEx,而ntdll.dll的NtCreateProcessEx 利用处理器的陷阱机制切换到内核模式下;在内核模式下,系统服务分发函数KiSystemService 获得控制,它利用当前线程指定的系统服务表,调用到执行体层的NtCreateProcessEx 函数。然后,执行体层的NtCreateProcessEx 函数执行前面介绍的进程创建逻辑,包括创建EPROCESS 对象、初始化其中的域、创建初始的进程地址空间、创建和初始化句柄表,并设置好EPROCESS 和KPROCESS 中的各种属性,如进程优先级、安全属性、创建时间等。到这里,执行体层的进程对象已经建立起来,进程的地址空间已经初始化,并且EPROCESS 中的PEB 也已初始化。

    第三阶段:创建初始线程

    这个阶段是通过调用NtCreateThread()完成的,主要包括: 现在,虽然进程对象已经建立起来,但是它没有线程,所以,它自己还不能做任何事情。接下来需要创建一个初始线程,在此之前,首先要构造一个栈以及一个可供运行的环境。初始线程的栈的大小可以通过映像文件获得,而创建线程则可以通过调用ntdll.dll 中的NtCreateThread 函数来完成。 创建和设置目标线程的ETHREAD数据结构,并处理好与EPROCESS的关系(例如进程块中的线程计数等等)。 在目标进程的用户空间创建并设置目标线程的TEB。 将目标线程在用户空间的起始地址设置成指向Kernel32.dll中的BaseProcessStart()或BaseThreadStart(),前者用于进程中的第一个线程,后者用于随后的线程。 用户程序在调用NtCreateThread()时也要提供一个用户级的起始函数(地址), BaseProcessStart()和BaseThreadStart()在完成初始化时会调用这个起始函数。 ETHREAD数据结构中有两个成份,分别用来存放这两个地址。 调用KeInitThread设置目标线程的KTHREAD数据结构并为其分配堆栈和建立执行环境。   特别地,将其上下文中的断点(返回点)设置成指向内核中的一段程序KiThreadStartup,使得该线程一旦被调度运行时就从这里开始执行。 系统中可能登记了一些每当创建线程时就应加以调用的“通知”函数,调用这些函数。

    第四阶段:通知windows子系统

    每个进程在创建/退出的时候都要向windows子系统进程csrss.exe进程发出通知,因为它担负着对windows所有进程的管理的责任, 注意,这里发出通知的是CreateProcess的调用者,不是新建出来的进程,因为它还没有开始运行。

    至此,CreateProcess的操作已经完成,但子进程中的线程却尚未开始运行,它的运行还要经历下面的第五和第六阶段。

    第五阶段:启动初始线程

    在内核中,新线程的启动例程是KiThreadStartup函数,这是当PspCreateThread 调用KeInitThread 函数时,KeInitThread 函数调用KiInitializeContextThread(参见base\ntos\ke\i386\thredini.c 文件)来设置的。

    KiThreadStartup 函数首先将IRQL 降低到APC_LEVEL,然后调用系统初始的线程函数PspUserThreadStartup。这里的PspUserThreadStartup 函数是PspCreateThread 函数在调用KeInitThread 时指定的,。注意,PspCreateThread函数在创建系统线程时指定的初始线程函数为PspSystemThreadStartup 。线程启动函数被作为一个参数传递给PspUserThreadStartup,在这里,它应该是kernel32.dll 中的BaseProcessStart。

    PspUserThreadStartup 函数被调用。逻辑并不复杂,但是涉及异步函数调用(APC)机制。

    新创建的线程未必是可以被立即调度运行的,因为用户可能在创建时把标志位CREATE_ SUSPENDED设成了1; 如果那样的话,就需要等待别的进程通过系统调用恢复其运行资格以后才可以被调度运行。否则现在已经可以被调度运行了。至于什么时候才会被调度运行,则就要看优先级等等条件了。

    第六阶段:用户空间的初始化和Dll连接

    PspUserThreadStartup 函数返回以后,KiThreadStartup 函数返回到用户模式,此时,PspUserThreadStartup 插入的APC 被交付,于是LdrInitializeThunk 函数被调用,这是映像加载器(image loader)的初始化函数。LdrInitializeThunk 函数完成加载器、堆管理器等初始化工作,然后加载任何必要的DLL,并且调用这些DLL 的入口函数。最后,当LdrInitializeThunk 返回到用户模式APC 分发器时,该线程开始在用户模式下执行,调用应用程序指定的线程启动函数,此启动函数的地址已经在APC 交付时被压到用户栈中。

    DLL连接由ntdll.dll中的LdrInitializeThunk()在用户空间完成。在此之前ntdll.dll与应用软件尚未连接,但是已经被映射到了用户空间 函数LdrInitializeThunk()在映像中的位置是系统初始化时就预先确定并记录在案的,所以在进入这个函数之前也不需要连接。

    展开全文
  • linux操作系统fork详解

    千次阅读 2016-08-21 10:48:48
    一、fork入门知识  一个进程,包括代码、数据和分配给进程的资源。fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程,也就是两个进程可以做完全相同的事,但如果初始参数或者传入的变量不同,两个...
  • 简述C语言fork()函数用法:

    千次阅读 2018-10-23 01:20:59
    首先了解 fork 的功能: fork调用的一个奇妙之处就是它仅仅被调用一次,却能够返回两次,它可能有三种不同的返回值: 1)在父进程中,fork返回新创建子进程的进程ID; 2)在子进程中,fork返回0; 3)如果出现错误,...
  • fork的简单使用

    2020-07-27 23:32:47
    在linux下通过代码来说明fork()创建的子进程与父进程之间的关系,以及他们之间独立运行的状态
  • fork()详解

    千次阅读 2018-07-31 13:04:55
    fork()函数用来创建新的进程,它的特点是调用一次返回两次( 在原来的进程中返回新进程的 PID(新进程的 PID 肯定不等于 0), 在新进程中返回为 0.) 函数原型:pid_t fork(void); pid_t getpid(); 获取当前...
  • Linux中fork,vfork和clone详解(区别与联系)

    万次阅读 多人点赞 2016-06-02 14:35:15
    fork,vfork,cloneUnix标准的复制进程的系统调用时fork(即分叉),但是Linux,BSD等操作系统并不止实现这一个,确切的说linux实现了三个,fork,vfork,clone(确切说vfork创造出来的是轻量级进程,也叫线程,是共享...
  • github fork 别人的项目源作者更新后如何同步更新

    万次阅读 多人点赞 2018-05-17 02:00:16
    1. 打开fork 过来的项目如下所示:2. 点击new pull request3. 在进入的界面, 后进行将左边的设置为你自己的仓库, fork 过来的源在右边, 如下图:4. 当选择完后会变成下图:5. 接下来, 将其展示出可以调整状态:...
  • Fork/Join框架基本使用

    万次阅读 2018-08-06 09:56:42
    1. 概述 ava.util.concurrent.ForkJoinPool由Java大师Doug Lea主持...本文中对Fork/Join框架的讲解,基于JDK1.8+中的Fork/Join框架实现,参考的Fork/Join框架主要源代码也基于JDK1.8+。 这几篇文章将试图解释Fork/...
  • Linux fork隐藏的开销-过时的fork(正传)

    千次阅读 多人点赞 2019-09-06 13:48:26
    本文来自《Linux fork那些隐藏的开销》 fork是一个拥有50年历史的陈年系统调用,它是一个传奇!时至今日,它依旧灿烂。 一个程序员可以永远不用read/write,也可以不懂mmap,但必须懂fork。这是一种格调! fork没有...
  • Fork/Join框架及模拟业务代码实现

    万次阅读 2020-08-29 11:40:37
    1.什么是Fork/Join框架 Fork/Join框架是Java7提供了的一个用于并行执行任务的框架, 是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。 我们再通过Fork和Join这两个单词来...
  • Fork/Join - 并发框架源码解析

    万次阅读 2019-03-29 09:47:28
    什么是Fork/Join框架 Fork/Join框架是Java7提供了的一个用于并行执行任务的框架, 是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。 我们再通过Fork和Join这两个单词来理解下Fork...
  • fork() || fork()和fork() && fork()笔试题

    千次阅读 2017-02-12 23:17:11
    程序一:int main() { fork() || fork(); printf("+"); return 0; } 结果输出3个”+”,共创建3个进程。...在main这个主进程中,首先执行 fork() || fork(), 左边的fork()返回一个非零值,根据||的短路
  • C++ fork函数理解

    千次阅读 2018-05-29 11:26:51
    调用fork的同时,我的理解是,已经在内存中创建了“副本”进程,同时返回pid,所以在返回值之前,已经是主进程和子进程同时在运行了(如果fork成功的话),这样,在程序的运行过程中,一次fork返回了两次值,在父...
  • 本文对forkjoin源码进行了深入的剖析,包含你想了解的关于forkjoin的几乎所有内容 由于篇幅太大,将原文拆分为4个部分,新手建议按照顺序阅读,不建议跳读 目录 一、ForkJoin全解1:简单使用与大致实现原理 二、...
  • 【Linux】关于理解fork()函数的简单例子

    万次阅读 多人点赞 2018-10-31 16:30:53
    1.fork()函数fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程,这个新产生的进程称为子进程。一个进程调用fork()函数后,系统先给新的进程分配资源,例如存储数据和代码的空间。然后把原来的进程的...
  • 文章目录fork join的用法fork join none的坑1. 回忆下fork-join_none2. fork-join_none翻车现场3. 再认识下for循环4. 怎么防止它的翻车disable fork用法 fork join的用法 我们早在学习Verilog语言时就学过:相对于...
  • 1. 什么是Fork/Join框架 Fork/Join框架是Java7提供了的一个用于并行执行任务的框架, 是一个把...我们再通过Fork和Join这两个单词来理解下Fork/Join框架,Fork就是把一个大任务切分为若干子任务并行的执行,Join就...
1 2 3 4 5 ... 20
收藏数 224,148
精华内容 89,659
关键字:

fork