2 
int main()
{
fork();
fork() && fork() || fork();
fork();

printf("forked\n");
return 0;
}

当我们调用 fork 函数时，父进程得到一个非零 pid，而子进程得到一个 0作为回报基于这个逻辑，在第二个语句中，我们将不得不应用短路原理（afaik）......在第一个之后调用会有2个过程，

在第二行之后，有 8 个进程，[A parent 在 ( fork() && fork() ) 中被分叉了两次，第二个孩子也因为“ fork()||fork() ”而分叉了两次]

最后是16（根据我的推理）

请让我知道这是否正确或涉及其他逻辑

4

2 回答 2

7

要计算 ( fork() && fork() || fork()) 之后的进程数，请记住：

  • In ( &&) 逻辑运算符：仅当左侧为非零时才计算右侧

  • In ( ||) 逻辑运算符：仅当左侧为零时才计算右侧

在运算符优先级的情况下，我们可以这样写：

(fork() && fork()) || fork()

还要记住，fork 将NON ZERO返回给parent并将ZERO返回给child

为了简化解释，我们重命名：

fork() && fork()操作A

和最后的 fork()操作 B，所以前面的行相当于：

( fork() && fork()) || fork()=> A || B

第一行( fork) ：

---> 2 个进程（父亲和孩子1）

第二行：

  • 一个操作：

第一个叉=>

父亲会给孩子 =>父亲（Child2 的 PID）和Child2（零） Child1 会给孩子 => Child1（ Child3 的 PID）和Child3（零）

我们有4 个进程：父亲（Child2 的 PID）、Child2（零）、Child1（Child3 的 PID）和 Child3（零）

( && fork()) 将仅对返回 NON ZERO => Father and Child1的最后一个操作执行

父亲将给一个孩子 =>父亲（Child4 的 PID）和Child4（零） Child1 将给一个孩子 => Child1（ Child5 的 PID）和Child5（零）

我们总结一下：

我们有6 个流程：

父亲（Child4 的 PID）、Child4（零）、Child1（Child5 的 PID）、Child5（零）、Child2（零）和 Child3（零）

  • B 操作：

仅对返回 ZERO =>从 A Operation 返回 ZERO的最后一个命令执行，相关进程是：

Child4（零）、Child5（零）、Child2（零）和 Child3（零）

当分叉这 4 个进程时，我们以 4 个新进程结束 =>Total number of process after second line = 10

第三行：这只是一个简单的分叉

=>进程总数 = 20

为了证明这一点：使用 this ( fork_quiz.c)

#include <unistd.h>
#include <stdio.h>

int main(int argc, char **argv)
{
        fork();
        fork() && fork() || fork();
        fork();

        sleep(10);

        return 0;
}

并编译它：

gcc -Wall fork_quiz.c -o fork_quiz

并像这样运行它：

toc@UnixServer:~$ ./fork_quiz & (sleep 1; ps -o "%P%p%c")
[1] 15455
 PPID   PID COMMAND
15046 15047 bash
15047 15455 fork_quiz
15047 15456 bash
15455 15457 fork_quiz
15455 15458 fork_quiz
15455 15459 fork_quiz
15455 15460 fork_quiz
15457 15462 fork_quiz
15457 15463 fork_quiz
15457 15464 fork_quiz
15458 15465 fork_quiz
15458 15466 fork_quiz
15459 15467 fork_quiz
15459 15468 fork_quiz
15465 15469 fork_quiz
15467 15470 fork_quiz
15463 15471 fork_quiz
15463 15472 fork_quiz
15462 15473 fork_quiz
15462 15474 fork_quiz
15473 15475 fork_quiz
15471 15476 fork_quiz
15456 15477 ps
于 2012-08-12T16:10:02.267 回答
1

让我们稍微重写一下程序来计算产生的进程：

#include <stdio.h>

int my_fork(const char *c) {
    int r = fork();
    if (!r) {
        fprintf(stderr, "process spawned at %s\n", c);
    }
    return r;
}

int main()
{
my_fork("a");
my_fork("b") && my_fork("c") || my_fork("d");
my_fork("e");

return 0;
}

启动后，您将看到 19 行代码process spawned，因此由于fork()调用而产生了 19 个进程：

~$ ./test
process spawned at a
process spawned at c
process spawned at c
process spawned at e
process spawned at e
process spawned at b
process spawned at d
process spawned at d
process spawned at e
process spawned at e
process spawned at e
process spawned at d
process spawned at e
process spawned at e
process spawned at b
process spawned at e
process spawned at d
process spawned at e
process spawned at e

UPD：考虑到C 中存在短路布尔评估，可以轻松计算进程数。

于 2012-08-12T14:32:42.503 回答