comment créer deux processus à partir d'un seul Parent

Pour créer un deuxième processus d'appel fork() de nouveau au sein de la société mère ou à l'enfant (mais pas les deux!). Qui que vous choisissez dépend de si vous voulez que ce processus d'être un enfant de l'original parent ou d'un enfant du premier enfant (il est habituel pour qu'il soit un enfant du parent d'origine).

Communiquer au moyen d'un tuyau est beaucoup plus simple et plus fiable que l'utilisation de signaux. pipe(), close(), read(), write() et select() sont les fonctions clés ici.

---

Par exemple, le parent créer deux processus enfants, vous voulez faire quelque chose comme:

pid_t child_a, child_b;

child_a = fork();

if (child_a == 0) {
    /* Child A code */
} else {
    child_b = fork();

    if (child_b == 0) {
        /* Child B code */
    } else {
        /* Parent Code */
    }
}

OriginalL'auteur caf

Vous pouvez mettre la fourche dans une boucle et générer autant de processus enfants que vous avez besoin.
Je l'ai fait sur un projet récemment.

for(nSon=0; nSon < nSonsAsked; nSon++) {
  Log_Print("Setup son #%.2u ", nSon+1);

  if((pid = fork()) == 0) {
    /* Do child stuff init, like connect the pipes, close shared handles */

    return iTMInChild(...);     /* A specific function of the child work */
  /* The life of the child should not go beyond that point, i.e. the loop is over 
     or else the child will spawn even more processes. */ 
  }
  else if(pid > 0) {
    /* Father process stuff. Here I initialise an array with the pid of the forked */
    /* processes, this way I can index with the number of processes.*/
    pid[nSon] = pid;
  }
  else
    return Err_Print(ERR_FORK_FAILED, "fork failed. errno=%d \"%s\"\n", errno, strerror(errno));
}

Log_Print() et Err_Print() sont des fonctions internes, mais tout à fait évident alors je les laisse comme ils sont.

Il y a un aspect avec les variables qui doit être expliqué. nSon et nSonAsked doivent être déclarés comme globals pas comme variables de pile. De cette façon, leur valeur persiste dans la fourche processus. Cela signifie que le nSon variable aura une valeur différente dans chacun des enfants. Cela lui permet d'avoir un simple schéma de numérotation de la ownpid() nombre.

Pour l'obtenir complètement à droite, il y a beaucoup de détails pour obtenir le droit. Vous aurez à définir les gestionnaires de signaux dans le processus père pour détecter la mort d'un enfant, de même dans l'autre sens (seulement possible sur Linux, Unix (au moins Solaris) ne supportent pas les parents des signaux de mort).
Vous devez être conscient du fait que les descripteurs de fichiers ouverts dans le processus père sera également ouvert à l'enfant après la fourche, et il sera le même un. Cela ouvre beaucoup de problèmes de concurrence d'accès si vous n'êtes pas au courant (la solution est d'utiliser dup() et close() dans les bons endroits).

OriginalL'auteur Patrick Schlüter

Dans cet exemple

ils sont juste dormir un peu aléatoire de la sec. Il a aussi tout le pid, afin que nous puissions envoyer SIGNAL pour communiquer...

la Plupart de la #inclut font l'objet de commentaires parce qu'ils étaient inutiles, où j'ai compilé.

#include <stdlib.h> //exit() ...
#include <stdio.h> //printf() ...

//Compile with -lrt -> cc file_name.c -lrt

//#include <fcntl.h>
//#include <sys/stat.h>
//#include <sys/types.h>
//#include <sys/wait.h> //may need this for wait()
//#include <time.h>

//#include <unistd.h> //and this one for fork()

//In the start function you can do whatever you want.
void start (const int azon) {
    //For children processes
    srand( time(NULL) );
    unsigned t = rand()%5; //printf("%d\n", t);
    sleep(t);
    printf("%d. process reached the end.\n", azon);
    exit(0);
}

int main() {
    const int N = 5;
    pid_t pids[N];

    int i;

    //The 'for' loop make 'N' process with 'fork()'.
    //The children processes will call the start function.
    //Since after fork() you will get 2 process. One Parent, and One Child
    //The returning value from fork() is saved in "pids" which is an
    //integer AND it is (<0) IF something went wrong.
    //            it is (>0) IF 'we are' in the Parent process,
    //because this number is the Child process' ID (pid).
    //and Last    it is (==0) IF 'we are' in the Child process.
    for (i = 0; i < N; i++) {
        pids[i] = fork();
        sleep(1);
        if (pids[i] == 0) start(i+1); //... OR you can make a switch(..)
    }
    //This 'for' loop in the wait(NULL) statement ONLY move on when a
    //process ended, so it waits until 'N' proc ends.
    for (i = 0; i < N; i++)
        wait(NULL);

    printf("Partent process reached the end\n");

    return 0;
}

OriginalL'auteur HovaMegy

#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
pid_t AliceID, BobID;
double n=0;
int i1 =0;
/* fork a child process */
AliceID = fork();

if (AliceID < 0) { /* error occurred */
fprintf(stderr, "Fork Failed");
return 1;
}
else if (AliceID == 0) { /* child Alice code */
    for(int i=1; i<11; i++)
          {n = n+i;
           i1++; }
        double avg1 = n/i1;
       printf("From Alice: the average of 1,2, …, 10 is the-average-she-calculated");
       printf("  sum = %.2f and avg = %.2f \n",n, avg1); 
     }
   else  { 
          BobID = fork();
         if (BobID == 0) { /* Child Bob code */
          printf("From Bob: I am born to print this and then die.\n");

        } else {  /* Parent Code */
                  /* parent will wait for the child to complete */
            wait(NULL);
            printf("From parent: AliceID is %d \n",  AliceID);
            printf("From parent: Bob is %d \n",  BobID);
            printf("Parent ID %d \n", getpid());

         }
}
return 0;
}

OriginalL'auteur MIGUEL A POLANCO