c - 为不同的工作生成 C 子进程？

Question

所以我正在尝试做一个 fork() 的应用程序两个 child 。

• 首先执行 for(i=1; i<=50000; i++)循环
• 第二个for(i=50000; i<=100000; i++)循环
• parent 做for(asciic=65; asciic<=90; asciic++) -> 打印 A 到 Z 字母的循环

我需要这三者同时工作，而不是一个接一个地工作。

我查看了互联网，但找不到合适的方法，我所能找到的只是创建子进程的循环，但它们做的事情几乎相同，而且大多数都是一个接一个地创建的。

感谢任何帮助。

为了更容易理解，这是我在发布之前所做的:

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

int main(void) {
    pid_t child_pid,child_pid1;
    int i=0;
    int stare;
    int asciic;

    child_pid=fork();
    child_pid1=fork();

    if (child_pid==0) {
        //printf("Father PID: %d -> Child 1: %d\n",getppid(),getpid());
        for(i=1; i<=50000; i++){
            printf("%d-%d\n",getpid(),i);
        }
        exit(0);
    } else if (child_pid1==0) {
        //printf("Father PID: %d -> Child 2: %d\n",getppid(),getpid());
        for(i=50000; i<=100000; i++) {
            printf("%d-%d\n",getpid(),i);
        }
        exit(0);
    } else {
        //printf("PID-ul procesului parinte: %d\n", getpid());
        pid_t rez=waitpid(child_pid,&stare,WNOHANG);
        pid_t rez1=waitpid(child_pid1,&stare,WNOHANG);
        while(rez==0 || rez1==0){
            for(asciic=65; asciic<=90; asciic++){
                printf("%d- %c\n",getpid(),asciic);
            }
            rez=waitpid(child_pid,&stare,WNOHANG);
            rez1=waitpid(child_pid1,&stare,WNOHANG);
        }

    }

    return 0;
}

如果我注释掉循环，我可以看到 child 有不同的 PID，1 个 child 有正确的父 PID，另一个有其他父 PID。

Answer 1

你的 2 行 fork :

child_pid=fork();
child_pid1=fork();

不要创建 2 个子节点，而是创建三个:父节点在第一个 fork() 中创建第一个子节点。从那一刻起，有 2 个进程:父进程和子进程。他们每个人都执行第二个 fork()。您将有 1 个 parent 、2 个 child 和 1 个孙子。

为了只有 1 个 parent 和 2 个 child ，您必须:

pid1 = fork();
if (pid1 < 0) {
    /* Error in fork() */
} else if (pid1 == 0) {
    /* first child */
    exit(0);
}

pid2 = fork();
if (pid2 < 0) {
    /* Error in fork() */
} else if (pid2 == 0) {
    /* second child */
    exit(0);
}

/* parent */

此外，即使您的代码是正确的，您也无法“查看”进程是否并发运行，或者不只是查看它们的输出。事实上，即使有多个进程“同时”执行，您也可能会看到其中一个进程在另一个进程启动之前完成。这是因为通常内核会进行时间多路复用，为每个子进程提供一些 CPU 时间。如果进程需要更长的时间才能完成，例如添加一些 sleep()，您可以看到并发性。