首页 > 试题广场 >

下列程序代码在Linux系统执行后"*"会被输出多少次()

[单选题]
下列程序代码在Linux系统执行后"*"会被输出多少次() 
void main()
{
   int i;
   for(i=0;i<3;i++)
   {
      fork();
      printf("*\n");
    }
  return;
}
  • 14
  • 16
  • 30
  • 32
查看答案及解析
添加回答
小水滴真的是太可爱了吧头像 小水滴真的是太可爱了吧
发表于 2019-12-28 15:26:27 回复(2)
樊烦头像 樊烦

一、fork入门知识

     一个进程，包括代码、数据和分配给进程的资源。fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，

也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。


    一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都

复制到新的新进程中，只有少数值与原来的进程的值不同。相当于克隆了一个自己。

我们来看一个例子：

[cpp] view plain copy
  1. 01. /*  
  2. 02. *  fork_test.c  
  3. 03. *  version 1  
  4. 04. *  Created on: 2010-5-29  
  5. 05. *      Author: wangth  
  6. 06. */     
  7. 07.#include <unistd.h>     
  8. 08.#include <stdio.h>      
  9. 09.int  main ()     
  10. 10.{     
  11. 11.    pid_t fpid; //fpid表示fork函数返回的值      
  12. 12.    int  count=0;    
  13. 13.    fpid=fork();     
  14. 14.    if  (fpid < 0)     
  15. 15.        printf("error in fork!" );     
  16. 16.    else   if  (fpid == 0) {    
  17. 17.        printf("i am the child process, my process id is %d/n" ,getpid());     
  18. 18.        printf("我是爹的儿子/n" ); //对某些人来说中文看着更直白。      
  19. 19.        count++;    
  20. 20.    }    
  21. 21.    else  {    
  22. 22.        printf("i am the parent process, my process id is %d/n" ,getpid());     
  23. 23.        printf("我是孩子他爹/n" );    
  24. 24.        count++;    
  25. 25.    }    
  26. 26.    printf("统计结果是: %d/n" ,count);    
  27. 27.    return  0;    
  28. 28.}    
  29. /* 
  30.  *  fork_test.c 
  31.  *  version 1 
  32.  *  Created on: 2010-5-29 
  33.  *      Author: wangth 
  34.  */   
  35. #include <unistd.h>   
  36. #include <stdio.h>    
  37. int  main ()   
  38. {   
  39.     pid_t fpid; //fpid表示fork函数返回的值   
  40.     int  count=0;  
  41.     fpid=fork();   
  42.     if  (fpid < 0)   
  43.         printf("error in fork!" );   
  44.     else   if  (fpid == 0) {  
  45.         printf("i am the child process, my process id is %d/n" ,getpid());   
  46.         printf("我是爹的儿子/n" ); //对某些人来说中文看着更直白。   
  47.         count++;  
  48.     }  
  49.     else  {  
  50.         printf("i am the parent process, my process id is %d/n" ,getpid());   
  51.         printf("我是孩子他爹/n" );  
  52.         count++;  
  53.     }  
  54.     printf("统计结果是: %d/n" ,count);  
  55.     return  0;  
  56. }  


 

运行结果是：
    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 plain copy
  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），代码内容为：

[cpp] view plain copy
  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），代码内容为：

[cpp] view plain copy
  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高阶知识”讲。
    总结一下，这个程序执行的流程如下：

 
摘选自 http://blog.csdn.net/myarrow/article/details/8995091
发表于 2016-03-13 10:43:57 回复(10)
大菜鸟大菜狗头像 大菜鸟大菜狗
A
注意这个题目中输出的时候有\n，刷新了缓冲区，所以只能是14个。
画一个二叉树可以快速得出
1                    。第一个不算
2             。            。（2）
3        。      。     。     。（4）
4      。 。 。 。 。 。 。 。（8）
发表于 2015-10-15 10:48:46 回复(10)
Aimer头像 Aimer

 fork2 = 1

 fork1=  fork2 + 2 = 3  (fork1 子进程执行过程中， i = 1 , 剩余循环 2 次，所以会打印 2 个 * ， fork0 同理，打印 3 个 * )

 fork0 = fork1+fork2 + 3 = 7 

 主进程 = fork0 + fork1+fork2 +3 = 7+3+1+3 = 14  

发表于 2015-10-30 14:35:58 回复(1)
卷王张三头像 卷王张三
教一个简单办法，也是在别的牛友上看到的。 一个fork, 打印两次 而fork形成的二叉树，最终有多少个进程多少个fork ,看二叉树末端。 这里层数是3，所以一共有7个叶子节点，所以说2*7 = 14
发表于 2016-10-31 18:55:16 回复(1)
你要offer不要头像 你要offer不要
第一个进程用 P 表示，
它的子进程用C+数字表示(C1/C2/C3)，
子进程的子进程同样加数字表示（C1子进程C11/C12/C13、、、）。
  1. i = 0    P    C1    --------------------------------------------------2个
  2. i = 1    P    C1    C2    C11--------------------------------------4个
  3. i = 2    P    C1    C2    C3    C11    C12    C111    C21---8个
所以共：2+4+8 = 14个
编辑于 2018-08-01 10:39:52 回复(0)
%^&&**头像 %^&&** 
设程序开始是P1进程，i=0时，fork出一个子进程P2（P2继承了P1的环境变量、PC环境等，所以P2也是i=0），然后P1打印*，P2打印*（因为printf中有\n所以没有缓冲区，直接输出）。
接着P1的i=1，P2的i=1，他们各自又执行fork产生各自的子进程，此时产生的进程i=1。
最后输出如下所示
   *       * i=0 两个星号对应的进程分别为 P1；P2
  *  *    *  * i=1 四个星号对应的进程分别为 P1；P1的子进程；P2；P2的子进程
 * ** *  * ** * i=2 这里不多说了
2+4+8=14个星号

编辑于 2017-07-18 13:55:27 回复(0)
Shy0418头像 Shy0418
fork（）创建一个进程与原来相同，所以i=0：有两个进程，输出2个 *；
i = 1 ：   fork() ->  4个进程，输出4个*；
i = 2 ：  fork() -> 8个进程，输出8个*；
总共有 2+4+8 = 14 个*。
发表于 2022-03-07 19:18:14 回复(0)
大杨头像 大杨
i = 0                                     i=1                          i=2
fork  -> 主线程print  fork ->主线程print   fork ->主线程print    
                                                                       ->子线程print    
                                                ->子线程print   fork   ->主线程 print    
                                                                       ->子线程print    
        -> 子线程print  fork   ->主线程print  fork  ->主线程 print    
                                                                      ->子线程print    
                                       ->子线程print   fork ->主线程 print    
                                                                      ->子线程print    
共有14个print
发表于 2015-10-14 23:24:48 回复(0)
Ailsa888头像 Ailsa888
总共三次循环，当i=0时，第一次循环输出2的1次方个*=2
当i=1时，第二次循环输出2的2次方个 *=4
当i=2时，第三次循环输出2的3次方个*=8
发表于 2017-09-24 20:44:16 回复(0)
blueyi头像 blueyi
图文并茂的讲解：http://notes.maxwi.com/2016/08/17/linux-fork/
发表于 2016-08-17 20:04:51 回复(3)
dy头像 dy
14
发表于 2015-10-27 14:38:15 回复(0)
陈让然头像 陈让然

当程序执行时，循环内的 fork() 语句会导致进程不断地分裂，每次分裂都会产生一个新的子进程。在这段代码中，fork() 语句被执行了3次，所以会产生 2^3 = 8 个进程（包括初始的父进程）。

具体的执行过程如下：

  1. 初始时，只有一个父进程存在。
  2. 在第一次循环中，父进程会分裂出一个子进程，此时有两个进程，每个进程输出一个 ""，所以屏幕上会有两个 ""。
  3. 进入第二次循环时，每个现有的进程（包括父进程和子进程）都会再次分裂，因此会产生四个新的进程。现在总共有 2 * 2 = 4 个进程，每个进程输出一个 ""，所以屏幕上会有四个 ""。
  4. 进入第三次循环时，每个现有的进程（包括之前的父进程和子进程）都会再次分裂，因此会产生八个新的进程。现在总共有 2 * 4 = 8 个进程，每个进程输出一个 ""，所以屏幕上会有八个 ""。

因此，最终会输出 8 个 "*"，所以答案是 A. 14。

发表于 2023-11-14 17:17:11 回复(0)
征途是星辰大海头像 征途是星辰大海

fork把当前进程的情况拷贝了一份，也即是说包括已经执行的代码的值。fork只拷贝下一个要执行的代码到新的进程。


发表于 2020-03-27 22:58:45 回复(0)
牛客7143217号头像 牛客7143217号
2×((2^n) -1) n是循环次数
编辑于 2017-11-27 08:49:48 回复(0)
棋手づ头像 棋手づ
fork就是有丝分裂啊，一个分两，两个分四个，第一个没结果不算
发表于 2022-11-24 14:31:49 回复(0)
天道酬勤**8头像 天道酬勤**8
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
void main()
{
   int i;
   pid_t pid;/*此时仅有一个进程*/
   for(i=0;i<3;i++)
   {
      pid=fork();
      printf("*\n");

      if(pid==0)
      {
        printf("Child process ID is %d\n",getpid());
      }
      else
      {
        printf("Parent process ID is %d\n",getpid());
      }
    }
  return;
}

发表于 2022-01-20 21:47:17 回复(0)
秋__头像 秋__
1+3+4+2+2
发表于 2021-09-18 04:27:09 回复(0)
一起拥有阳光头像 一起拥有阳光
 fork只拷贝下一个要执行的代码到新的进程。
发表于 2019-02-20 10:13:58 回复(0)
张柱华头像 张柱华
2+2^2+2^3=14
发表于 2017-10-08 15:33:20 回复(0)
提交观点

问题信息

C++工程师 运维工程师 算法工程师 PHP工程师 Linux Java工程师
来自：美丽联合2016研发工...
难度：
23条回答 13485浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号