创建多代子进程

Question

所以我试图理解孙辈的概念。 我能够创造给定数量的儿子(即兄弟)，但我不知道如何创造多代。 这就是我创造一个孙子所做的:

int main ()
{
//Displaying the father
printf("Initial : Father = %d\n\n", getpid()); 

/****** FORK *******/

pid_t varFork, varFork2;

varFork = fork();

if(varFork == -1) //If we have an error, we close the process
{
    printf("ERROR\n");
    exit(-1);
}
else if (varFork == 0) //if we have a son, we display it's ID and it's father's
{
    printf("SON 1\n");
    printf(" ID = %d, Father's ID = %d\n", getpid(), getppid());

    varFork2 = fork();//creation of the second fork

    if(varFork2 == -1) //If we have an error, we close the process
    {
        printf("ERROR\n");
        exit(-1);
    }
    else if (varFork2 == 0) //now we have the son of the first son, so the grandson of the father
    {
        printf("\nGRANDSON 1\n");
        printf(" ID = %d, Father's ID = %d\n", getpid(), getppid());
    }
    else sleep(0.1);/*we wait 0.1sec so that the father doesn't die before we can 
        display it's id (and before the son process gets adopted by a user process descending from the initial              process)*/  
}
else //in the other case, we have a father
{
    sleep(0.1);//again we put the father asleep to avoid adoption
}
return 0;
}

如何创建 X 代孙子，X 是一个全局变量(1 个儿子、1 个孙子、1 个曾孙等)？

Answer 1

How can I create X generations

在 fork 之前，递减 X 并继续在 child 内部 fork ，直到 X 为 0。

或者在子进程内部递减 X 并且只有在递减 X 之后仍然大于 0 时才继续 fork 。

代码可能是这样的:

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

void logmsg(const char *, int);

#define MAX_GENERATIONS (4)

int main(void)
{
  pid_t pid = 0;

  for (size_t g = 0; g < MAX_GENERATIONS; ++g)
  {
    logmsg("About to fork.", 0);

    switch (pid = fork())
    {
      case -1:
      {
        logmsg("fork() failed", errno);

        break;
      }

      case 0:
      {
        logmsg("Hello world. I am the new child.", 0);

        break;
      }

      default:
      {
        char s[1024];
        snprintf(s, sizeof s, "Successfully created child carrying PID %d.", (int) pid);
        logmsg(s, 0);
        g = MAX_GENERATIONS; /* Child forked, so we are done, set g to end looping. */

        break;
      }
    }
  }

  logmsg("Sleeping for 3s.", 0);
  sleep(3);

  if (0 != pid) /* In case we forked a child ... */
  {
    logmsg("Waiting for child to end.", 0);
    if (-1 == wait(NULL)) /* ... wait for the child to terminate. */
    {
      logmsg("wait() failed", errno);
    }
  }

  logmsg("Child ended, terminating as well.", 0);

  return EXIT_SUCCESS;
}

void logmsg(const char * msg, int error)
{
  char s[1024];
  snprintf(s, sizeof s, "PID %d: %s", (int) getpid(), msg);
  if (error)
  {
    errno = error;
    perror(s);
    exit(EXIT_FAILURE);
  }

  puts(s);
}

输出应该类似于这样:

PID 4887: About to fork.
PID 4887: Successfully created child carrying PID 4888.
PID 4887: Sleeping for 3s.
PID 4888: Hello world. I am the new child.
PID 4888: About to fork.
PID 4888: Successfully created child carrying PID 4889.
PID 4888: Sleeping for 3s.
PID 4889: Hello world. I am the new child.
PID 4889: About to fork.
PID 4889: Successfully created child carrying PID 4890.
PID 4890: Hello world. I am the new child.
PID 4890: About to fork.
PID 4889: Sleeping for 3s.
PID 4890: Successfully created child carrying PID 4891.
PID 4890: Sleeping for 3s.
PID 4891: Hello world. I am the new child.
PID 4891: Sleeping for 3s.
PID 4888: Waiting for child to end.
PID 4890: Waiting for child to end.
PID 4891: Child ended, terminating as well.
PID 4890: Child ended, terminating as well.
PID 4887: Waiting for child to end.
PID 4889: Waiting for child to end.
PID 4889: Child ended, terminating as well.
PID 4888: Child ended, terminating as well.
PID 4887: Child ended, terminating as well.

与我提出的建议相比，我上面的代码的不同之处在于它向上计数到 X。