C 如何暂停进程并继续程序？

我想知道是否有一种方法可以暂停进程，但继续程序

我需要创建如下流程：

但当我点击P4时，它结束了，消失了，然后P2创建了P5。然后P2死亡，P1创建P3，同样的事情在那里发生

我需要在进程开始消亡之前创建整个“树”。
不能使用

wait

或

waitpid（）

，因为它只针对它的子对象

有没有办法暂停P4并从它的父亲那里继续？
如果我不能，我怎么能实现我的目标

我当前的代码：按以下顺序创建：

P1->P2->P4->P4模具->P5->P5模具->P2模具-> P3->P6->P6模具->P7->P7模具->P3模具->P1模具

#包括
#包括
#包括
#包括
#包括
int main（）{
时钟；
双倍时间；
t=时钟（）；
智力状态；
pid_t Idproceso，pai；
printf（“P1已创建：%d\n”，getpid（））；
idProcesso=fork（）；
交换机（idProcesso）
{
案例1：出口（1）；
案例0://P2
printf（“P2创建：%d-P1的子：%d\n”，getpid（），getppid（））；
idProcesso=fork（）；
交换机（idProcesso）
{
案例1：出口（1）；
案例0://P4
printf（“P4创建：%d-P2的子：%d\n”，getpid（），getppid（））；
睡眠（1）；
打破
default://P2
idProcesso=fork（）；
交换机（idProcesso）
{
案例1：出口（1）；
案例0://P5
printf（“P5创建：%d-P2的子：%d\n”，getpid（），getppid（））；
打破
default://P2
睡眠（1）；
打破
}
打破
}
打破
违约：
idProcesso=fork（）；
交换机（idProcesso）
{
案例1：出口（1）；
案例0://P3
printf（“P3已创建：%d-P1的儿子：%d\n”，getpid（），getppid（））；
idProcesso=fork（）；
交换机（idProcesso）
{
案例1：出口（1）；
案例0://P6
printf（“P6创建：%d-P3的子：%d\n”，getpid（），getppid（））；
睡眠（1）；
打破
default://P3
idProcesso=fork（）；
交换机（idProcesso）
{
案例1：出口（1）；
案例0://P7
printf（“P7创建：%d-P3的子：%d\n”，getpid（），getppid（））；
打破
default://P3
打破
}
睡眠（1）；
打破
}
打破
违约：
睡眠（4）；
打破
}
打破
}
printf（“进程id:%d已终止\n”，getpid（））；
出口（0）；
}

进程彼此独立运行，因此您只需：

让您的子进程保持活动状态足够长的时间，以便创建所有进程，例如，使用

sleep（）

，这很容易做到；及

在创建完所有子进程之前，不要启动任何子进程的

wait（）

ing

下面是一个例子：

#define _POSIX_C_SOURCE 200809L

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

int main(void)
{
    pid_t pids[8] = {0};
    printf("P1 created (%lu).\n", (unsigned long) getpid());

    for ( size_t i = 1; i < 3; ++i ) {
        pids[i] = fork();

        if ( pids[i] == -1 ) {
            perror("fork() error");
            exit(EXIT_FAILURE);
        }
        else if ( pids[i] == 0 ) {
            printf("P%zu created (%lu).\n", i + 1, (unsigned long) getpid());

            for ( size_t j = 1 + i * 2; j < 3 + i * 2; ++j ) {
                pids[j] = fork();

                if ( pids[j] == -1 ) {
                    perror("fork() error");
                    exit(EXIT_FAILURE);
                }
                else if ( pids[j] == 0 ) {
                    printf("P%zu created (%lu).\n", j + 1,
                            (unsigned long) getpid());
                    sleep(8 - j);
                    printf("P%zu exiting.\n", j + 1);
                    exit(EXIT_SUCCESS);
                }
            }

            for ( size_t j = 2 + i * 2; j >= 1 + i * 2; --j ) {
                if ( waitpid(pids[j], NULL, 0) == -1 ) {
                    perror("waitpid() error");
                    exit(EXIT_FAILURE);
                }
                printf("Waited for P%zu (%lu).\n", j + 1,
                        (unsigned long) pids[j]);
            }

            printf("P%zu exiting.\n", i + 1);
            exit(EXIT_SUCCESS);
        }
    }

    for ( size_t i = 2; i > 0; --i ) {
        if ( waitpid(pids[i], NULL, 0) == -1 ) {
            perror("waitpid() error");
            exit(EXIT_FAILURE);
        }
        printf("Waited for P%zu (%lu).\n", i + 1, (unsigned long) pids[i]);
    }

    printf("P1 exiting.\n");

    return 0;
}

请注意，进程的运行顺序本质上是不可预测的，因此每次运行时，您可能会得到与上面略有不同的结果。我没有试图让它们按顺序创建或退出，除了在四叶进程中半心半意地尝试

sleep（）。您几乎可以通过对
sleep（）
的策略调用来保证执行和终止顺序，或者使用某种形式的进程间通信来保证执行和终止顺序。一般来说，你不应该关心这个顺序，而应该关心你的实际工作是否按顺序完成

但是，它满足了在任何进程开始死亡之前保持所有进程处于活动状态的标准。
在最近的linux上，您可以重新设置进程的父进程：您需要同时运行所有7个进程，或者连续构建树，根/分支会随着时间的推移而消失？p7应为最后一个工艺站？和。。为什么不能使用一些传统的同步机制呢？就像管道一样。@MarcB是的，我需要创建所有管道，然后将它们全部杀死。我只能创建一面，杀死它，然后开始创建另一面。不知道如何创建右侧和保持左侧活动。P2没有理由在创建P5之前等待P4。谢谢。编译您的代码时，我得到了以下信息：
P1（3808）、P3（3810）、P2（3809）
->不同的顺序，但我们可以看到，由于Pids，它是正常的。但现在我有：
P6（3811）P4（3813）P7（3812）P5（3814）
。由于PID的顺序不同，这难道不意味着它是以错误的顺序创建的吗？@PlayHardGoPro：我建议你参考我回答的这一部分：“请注意，进程运行的顺序本质上是不可预测的”。你太棒了！工作完美。但是我不明白为什么会有这些循环。我更新了我的代码，它创建的很好，但进程并没有按照正确的顺序消亡。（孩子先于父母）。您可以快速查看一下吗？

的

循环存在，因为每个父进程必须创建两个子进程。实际上，任何时候只要你想做一件事不止一次，你就会想要
#define _POSIX_C_SOURCE 200809L

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

int main(void)
{
    pid_t pids[8] = {0};
    printf("P1 created (%lu).\n", (unsigned long) getpid());

    for ( size_t i = 1; i < 3; ++i ) {
        pids[i] = fork();

        if ( pids[i] == -1 ) {
            perror("fork() error");
            exit(EXIT_FAILURE);
        }
        else if ( pids[i] == 0 ) {
            printf("P%zu created (%lu).\n", i + 1, (unsigned long) getpid());

            for ( size_t j = 1 + i * 2; j < 3 + i * 2; ++j ) {
                pids[j] = fork();

                if ( pids[j] == -1 ) {
                    perror("fork() error");
                    exit(EXIT_FAILURE);
                }
                else if ( pids[j] == 0 ) {
                    printf("P%zu created (%lu).\n", j + 1,
                            (unsigned long) getpid());
                    sleep(8 - j);
                    printf("P%zu exiting.\n", j + 1);
                    exit(EXIT_SUCCESS);
                }
            }

            for ( size_t j = 2 + i * 2; j >= 1 + i * 2; --j ) {
                if ( waitpid(pids[j], NULL, 0) == -1 ) {
                    perror("waitpid() error");
                    exit(EXIT_FAILURE);
                }
                printf("Waited for P%zu (%lu).\n", j + 1,
                        (unsigned long) pids[j]);
            }

            printf("P%zu exiting.\n", i + 1);
            exit(EXIT_SUCCESS);
        }
    }

    for ( size_t i = 2; i > 0; --i ) {
        if ( waitpid(pids[i], NULL, 0) == -1 ) {
            perror("waitpid() error");
            exit(EXIT_FAILURE);
        }
        printf("Waited for P%zu (%lu).\n", i + 1, (unsigned long) pids[i]);
    }

    printf("P1 exiting.\n");

    return 0;
}

paul@horus:~/src/sandbox$ ./procs
P1 created (27206).
P2 created (27207).
P3 created (27208).
P4 created (27209).
P5 created (27210).
P6 created (27211).
P7 created (27212).
P7 exiting.
Waited for P7 (27212).
P6 exiting.
Waited for P6 (27211).
P3 exiting.
Waited for P3 (27208).
P5 exiting.
Waited for P5 (27210).
P4 exiting.
Waited for P4 (27209).
P2 exiting.
Waited for P2 (27207).
P1 exiting.
paul@horus:~/src/sandbox$