C中的fork（）函数

Question

下面是 Fork 函数的示例。下面也是输出。我的主要问题与叉子有关，称为如何更改值。所以 pid1,2 和 3 从 0 开始，并随着分叉的发生而改变。这是因为每次分叉发生时，值都会被复制到子级并且父级中的特定值会发生变化？基本上值如何随 fork 函数变化？

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    pid_t pid1, pid2, pid3;
    pid1=0, pid2=0, pid3=0;
    pid1= fork(); /* A */
    if(pid1==0){
        pid2=fork(); /* B */
        pid3=fork(); /* C */
    } else {
        pid3=fork(); /* D */
        if(pid3==0) {
            pid2=fork(); /* E */
        }
        if((pid1 == 0)&&(pid2 == 0))
            printf("Level 1\n");
        if(pid1 !=0)
            printf("Level 2\n");
        if(pid2 !=0)
           printf("Level 3\n");
        if(pid3 !=0)
           printf("Level 4\n");
       return 0;
    }
}

然后这就是执行。

----A----D--------- (pid1!=0, pid2==0(as initialized), pid3!=0, print "Level 2" and "Level 4")
    |    |
    |    +----E---- (pid1!=0, pid2!=0, pid3==0, print "Level 2" and "Level 3")
    |         |
    |         +---- (pid1!=0, pid2==0, pid3==0, print "Level 2")
    |
    +----B----C---- (pid1==0, pid2!=0, pid3!=0, print nothing)
         |    |
         |    +---- (pid1==0, pid2==0, pid3==0, print nothing)
         |
         +----C---- (pid1==0, pid2==0, pid3!=0, print nothing)
              |
              +---- (pid1==0, pid2==0, pid3==0, print nothing)

理想情况下，下面是我希望看到的解释方式，因为这种方式对我来说很有意义。 * 是我的主要困惑所在。例如，当孩子分叉pid1 = fork(); 时，它创建了一个包含父进程所有值的进程，但它是否会传递一个值，比如让我们说 1 给父进程 pid1？这意味着孩子将有 pid 1=0、pid2=0 和 pid3=0，而父母则为 pid1=2 和 pid2 和 3 等于 0？

Answer 1

我认为您创建的每个进程都开始执行您创建的行，所以像这样......

pid=fork() at line 6. fork function returns 2 values 
you have 2 pids, first pid=0 for child and pid>0 for parent 
so you can use if to separate

.

/*
    sleep(int time) to see clearly
    <0 fail 
    =0 child
    >0 parent
*/
int main(int argc, char** argv) {
    pid_t childpid1, childpid2;
    printf("pid = process identification\n");
    printf("ppid = parent process identification\n");
    childpid1 = fork();
    if (childpid1 == -1) {
        printf("Fork error !\n");
    }
    if (childpid1 == 0) {
        sleep(1);
        printf("child[1] --> pid = %d and  ppid = %d\n",
                getpid(), getppid());
    } else {
        childpid2 = fork();
        if (childpid2 == 0) {
            sleep(2);
            printf("child[2] --> pid = %d and ppid = %d\n",
                    getpid(), getppid());
        } else {
            sleep(3);
            printf("parent --> pid = %d\n", getpid());
        }
    }
    return 0;
}

//pid = process identification
//ppid = parent process identification
//child[1] --> pid = 2399 and  ppid = 2398
//child[2] --> pid = 2400 and ppid = 2398
//parent --> pid = 2398

linux.die.net

some uni stuff

Answer 2

系统调用 fork() 用于创建进程。它不接受任何参数并返回一个进程 ID。 fork() 的目的是创建一个新进程，该进程成为调用者的子进程。创建新的子进程后，两个进程都将执行 fork() 系统调用之后的下一条指令。因此，我们必须区分父母和孩子。这可以通过测试 fork() 的返回值来完成

Fork 是一个系统调用，你不应该把它当作一个普通的 C 函数。当 fork() 发生时您有效地创建了两个具有自己地址空间的新进程。在 fork() 调用之前初始化的变量在两个地址空间中存储相同的值。但是，在任一进程的地址空间内修改的值在其他进程中不受影响，其中一个是父进程，另一个是子进程。 所以如果，

pid=fork();

如果您在随后的代码块中检查 pid 的值。两个进程都会运行整个代码长度。那么我们如何区分它们。 Fork 是一个系统调用，这里有区别。在新创建的子进程中，pid 将存储 0，而在父进程中它将存储一个正值。pid 中的负值表示 fork 错误。

当我们测试 pid 的值时 找出它是等于零还是大于它，我们实际上是在找出我们是在子进程还是父进程中。

Read more about Fork

Answer 3

首先是一些 fork() 文档的链接

http://pubs.opengroup.org/onlinepubs/009695399/functions/fork.html

pid 由内核提供。每次内核创建一个新进程时，它都会增加内部 pid 计数器并为新进程分配这个新的唯一 pid，并确保没有重复。一旦 pid 达到某个较高的数字，它将重新包装并重新开始。

所以你永远不知道你会从 fork() 中得到什么 pid，只有父进程会保持它的唯一 pid，而 fork 会确保子进程将有一个新的唯一 pid。上面提供的文档中对此进行了说明。

如果您继续阅读文档，您将看到 fork() 为子进程返回 0，并且子进程的新唯一 pid 将返回给父进程。如果孩子想知道它自己的新 pid，您必须使用 getpid() 查询它。

pid_t pid = fork()
if(pid == 0) {
    printf("this is a child: my new unique pid is %d\n", getpid());
} else {
    printf("this is the parent: my pid is %d and I have a child with pid %d \n", getpid(), pid);
}

以下是您代码中的一些内联 cmets

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    pid_t pid1, pid2, pid3;
    pid1=0, pid2=0, pid3=0;
    pid1= fork(); /* A */
    if(pid1 == 0){
        /* This is child A */
        pid2=fork(); /* B */
        pid3=fork(); /* C */
    } else {
        /* This is parent A */
        /* Child B and C will never reach this code */
        pid3=fork(); /* D */
        if(pid3==0) {
            /* This is child D fork'ed from parent A */
            pid2=fork(); /* E */
        }
        if((pid1 == 0)&&(pid2 == 0)) {
            /* pid1 will never be 0 here so this is dead code */
            printf("Level 1\n");
        }
        if(pid1 !=0) {
            /* This is always true for both parent and child E */
            printf("Level 2\n");
        }
        if(pid2 !=0) {
           /* This is parent E (same as parent A) */
           printf("Level 3\n");
        }
        if(pid3 !=0) {
           /* This is parent D (same as parent A) */
           printf("Level 4\n");
        }
    }
    return 0;
}

Answer 4

int a = fork(); 

创建一个重复的进程“克隆？”，它共享执行堆栈。父子的区别在于函数的返回值。

得到 0 的子进程返回，父进程得到新的 pid。

每次复制堆栈变量的地址和值。在代码中已经到达的位置继续执行。

在每个fork，只有一个值被修改——来自fork的返回值。