在视觉上发生了什么 fork// 在 For Loop

我试图了解行为
fork//

. 这个时候了
for-loop

. 遵守以下代码：


#include <stdio.h>



void main//

{

 int i;



 for /i=0;i&lt;3;i++/

 {

 fork//;



 // This printf statement is for debugging purposes

 // getppid//: gets the parent process-id

 // getpid//: get child process-id



 printf/"[%d] [%d] i=%d\n", getppid//, getpid//, i/;

 }



 printf/"[%d] [%d] hi\n", getppid//, getpid///;

}


这是结果

:


[6909][6936] i=0

[6909][6936] i=1

[6936][6938] i=1

[6909][6936] i=2

[6909][6936] hi

[6936][6938] i=2

[6936][6938] hi

[6938][6940] i=2

[6938][6940] hi

[1][6937] i=0

[1][6939] i=2

[1][6939] hi

[1][6937] i=1

[6937][6941] i=1

[1][6937] i=2

[1][6937] hi

[6937][6941] i=2

[6937][6941] hi

[6937][6942] i=2

[6937][6942] hi

[1][6943] i=2

[1][6943] hi


我是一个非常可视的人，因​​此我真正了解事情的唯一方法是抽取图表。 我的教练说 8

欢迎

陈述。 我写了并推出了代码，实际上是 8 运营商

hi

. 但我真的不明白这一点。 因此，我画了下图：


该图已用评论更新 :/

观察结果：

父流程 /主要的/ 必须重复周期 3 时代。 然后 printf 叫

在父母的每次迭代 for-loop a fork// 叫

在每次挑战后 fork// i 每个孩子都会增加 for-loop 从 i 在增加之前

在每个人的尽头 for-loop 打印 "hi"

以下是我的问题：

我的计划是真的吗？

为什么输出

二

实例
i=0

?

什么价值
i

之后转移到每个孩子 fork//? 如果相同的价值
i

当 "forking" 停下来？

它总是这样
2^n - 1

有能力计算扭曲的孩子数量吗？ 所以在这里
n=3

, 什么方式
2^3 - 1 = 8 - 1 = 7

孩子们，是对的吗？
</stdio.h>
2021-03-20 添加评论
分享

没有找到相关结果

    已邀请:

    卫东

    赞同来自:

    以下是如何理解它，从循环开始
    for

    .

    循环从父母开始，
    i == 0


    父母
    fork//

    C，创建后代 1.

    现在你有两个进程。 两者都是印刷的
    i=0

    .

    循环在两个过程中重新启动，现在
    i == 1

    .

    父母和孩子 1
    fork//

    , 创造孩子 2 和 3.

    现在你有四个进程。 所有四个都是印刷的
    i=1

    .

    现在在所有四个过程中重新启动该循环
    i == 2

    .

    父母和孩子们 1 经过 3 全部
    fork//

    , 创造儿童S. 4 经过 7.

    现在你有八个进程。 所有八个印刷品
    i=2

    .

    现在，该循环在所有八个过程中重新启动
    i == 3

    .

    该循环在所有八个过程中完成，因为
    i < 3

    不再是真的。

    印刷所有八个流程
    hi

    .

    所有八个流程都已完成。

    所以你得到了
    0

    打印两次
    1

    印刷四次
    2

    打印 8 有一次，我。
    hi

    打印 8 时间。
    2021-03-20 0 0
    分享

    冰洋

    赞同来自:

    恩，那就对了。 /见下文/

    不是，
    i++

    执行

    后

    称呼
    fork

    , 因为循环工作
    for

    .

    如果一切顺为成功，那么是的。 但请记住
    fork

    可能会失败。

    第二个解释：


    for /i = 0;i < 3; i++/
    
{
    
 fork//;
    
}


    看起来像：


    i = 0;
    
while /i < 3/
    
{
    
 fork//;
    
 i++;
    
}


    因此，
    i

    在分裂过程中/父母和子公司/ - 此值在增量之前。 但是，递增在后立即执行
    fork//

    , 因此，在我看来，该图可以被认为是正确的。
    2021-03-20 0 0
    分享

    风见雨下

    赞同来自:

    逐一回答您的问题：

    我的计划是真的吗？

    是的，基本上。 此外，这是一个非常好的计划。

    也就是说，如果您解释标签是正确的
    i=0

    与完整周期的迭代相关。 但是图表

    不是

    显示在每个之后
    fork//

    呼叫后循环当前迭代的一部分
    fork//

    也由分叉的女儿进程进行。

    为什么输出中有两个副本
    i=0

    ?

    因为你有
    printf//

    后
    fork//

    , 因此，它是作为父过程进行的，只是刻破了女儿过程。 如果你搬家
    printf//

    正面
    fork//

    , 它只由父母执行 /由于子进程尚不存在/.

    什么价值
    i

    之后转移到每个孩子
    fork//

    ? 如果相同的价值
    i

    当 "forking" 停下来？

    价值
    i

    没有改变
    fork//

    , 因此，子流程认为与其父母相同的含义。

    关于
    fork//

    应该记住它被调用一次，但返回两次 - 它在父进程中一次，并在新克隆的子进程中一次。

    对于更简单的示例，请考虑以下代码：


    printf/"This will be printed once.\n"/;
    
fork//;
    
printf/"This will be printed twice.\n"/;
    
fork//;
    
printf/"This will be printed four times.\n"/;
    
fork//;
    
printf/"This will be printed eight times.\n"/;


    女儿创造的
    fork//

    , 是一个 /几乎/ 他的父母准确的克隆，因此，从他自己的角度来看，他 "remembers" 是他的父父，继承父流程的整个状态 /包括变量的所有值，调用堆栈和可执行指令/. 唯一的直接区别 /除了系统元数据 , 如过程 ID, 返回
    getpid//

    / 是一个退货价值
    fork//

    , 在子程序中将是零，但非零 /实际上， ID 女儿过程/ 在父母。

    它总是这样
    2^n - 1

    有能力计算扭曲的孩子数量吗？ 所以在这里
    n=3

    , 什么方式
    2^3 - 1 = 8 - 1 = 7

    孩子们，是对的吗？

    每个过程执行
    fork//

    , 变成了两个进程 /除了不寻常的错误条件
    fork//

    可能会失败/. 如果父母和后代继续执行相同的代码 /也就是说，它们不检查返回值
    fork//

    或者你自己的进程 ID 并基于它分支在不同的代码上/, 然后每个随后 fork 移动流程数。 所以，是的，在三个地块之后，您将收到总共 2³ = 8 流程。
    2021-03-20 0 0
    分享
    为什么被折叠? 0 个回复被折叠

    要回复问题请先登录或注册

    Copyright © 2023, All Rights Reserved