Question

我已经问了一个关于fork（）的问题，这是另一个问题。给出以下代码：

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

int main()
{
    pid_t pid1, pid2;
    pid1 = fork();
    pid2 = fork();
    if (pid1 != 0 && pid2 != 0)
        printf("A\n");
    if (pid1 != 0 || pid2 != 0)
        printf("B\n");
    exit(0);
}

在第二个fork()之后，pid1＆amp;的价值是多少？ pid2？
据了解，第一个fork设置了pid1 > 0，并且在以后创建的所有子项中都是相同的。但是，pid2会发生什么？

谢谢！

Answer 1

Fork将进程置于其现有状态并克隆它，因此现在您有两个相同的副本。在原始进程中，fork然后返回新克隆进程的PID。在新克隆中，fork返回0.

Parent process:
pid1 = PID of child 1
pid2 = PID of child 3

Child 1
pid1 = 0
pid2 = PID of child 2

Child 2
pid1 = 0
pid2 = 0

Child 3
pid1 = PID of child 1
pid2 = 0

Answer 2

您所要做的就是尝试：

#include <unistd.h>
#include <stdio.h>
int main (void) {
    pid_t pid1 = -1, pid2 = -1;
    pid1 = fork();
    pid2 = fork();
    printf ("%5d/%5d: %5d %5d\n", getpid(), getppid(), pid1, pid2);
    sleep (5); // to prevent inheritance by init process on parent death
    return 0;
}

你会看到：

  PID/ PPID   pid1  pid2
 ----------   ----  ----
 2507/ 2386:  2508  2509      first process
 2508/ 2507:     0  2510      first fork from 'first process'
 2509/ 2507:  2508     0      second fork from 'first process'
 2510/ 2508:     0     0      second fork from "first fork from 'first process'"

换句话说：

第一个流程2507将pid1和pid2设置为其两个孩子。
第二个进程2508的pid1为0，因为它是该分叉中的子代，而{25}的pid2因为它是中的父分叉。
第三个进程2509从第一个进程（其父进程）继承pid1，因为它在之后设置了。它的pid2为0，因为它是第二个叉子中的孩子。

第四个进程2510从第二个进程（其父进程）继承pid1，因为它在设置之后分叉。它的pid2也是0，因为它是第二个叉子中的孩子。

Answer 3

我准备为你测试一下，但是让我告诉你我的期望。

                               / pid2=[child3 pid]    { pid1 = child1;pid2 = child3;}
        pid1=[child1 pid] fork()
       /                       \
      /                          pid2=0               { pid1 = child1;pid2 = 0;}
fork()
      \                          pid2=[child2 pid]    { pid1 = 0;     pid2 = child2;}
       \                       /
        pid1=0         - fork()
                               \ 
                                 pid2=0               { pid1 = 0;     pid2 = 0;}

编辑经过测试。代码如下

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

int main()
{
    pid_t pid1, pid2;
    pid1 = fork();
    pid2 = fork();
    printf("PID %d: pid1=%d, pid2=%d\n",getpid() ,pid1, pid2);
    exit(0);
}

输出：

PID 30805：pid1 = 30806，pid2 = 30807
  PID 30806：pid1 = 0，pid2 = 30808
  PID 30807：pid1 = 30806，pid2 = 0
  PID 30808：pid1 = 0，pid2 = 0

Answer 4

在第二个fork（）之后，pid1＆amp;的值是多少？ pid2？

这取决于您正在谈论的流程。这里有四个过程（包括原始过程），它们之间有以下关系：

A (original process)
` - B (created by first fork in original process)
|   ` - C (created by second fork in B)
` - D (created by second fork in original process)

所以在A，pid1 > 0和pid2 > 0中，因为它在每个fork上创建了新进程。

在B中，pid1 == 0和pid2 > 0，因为它是由第一个分叉创建的，并在第二个分支中创建了一个新进程。

在C中，pid1 == 0和pid2 == 0，因为它从父级（B）继承pid1的值，并由第二个分叉创建。

在D中，pid1 > 0和pid2 == 0，因为它从父级（A）继承pid1的值，并由第二个分叉创建。

当然，请记住，这些只是初始条件。每个进程都有自己的值副本，因此即使进程从其父进程继承某个变量的初始值，仍然可以在fork之后更改它而不影响父进程的副本。

Answer 5

阅读手册页：http://linux.die.net/man/2/fork

因此，pid1将在第一个fork中创建的第一个进程的子进程中为0，而在main和第二个子进程中则为其他进程。 pid2在第一个进程的孙子中为0，在主进程的第二个fork中创建子进程。其他地方的其他东西。

                                            /-[parent]pid1=?, pid2=?
      /-[parent]pid1=?, pid2=uninit -> fork()
fork()                                      \-[child2 of parent]pid1=?, pid2=0
     \
      \                                               /-[child1 of parent]pid1=0,pid2=?
       \[child1 of parent] pid1=0, pid2=uninit -> fork()
                                                      \-[child of child] pid1=0, pid2=0

Fork（）子句中的变量值

5 个答案: