LPNHE - UMR 7585 - fork, ou comment créer des processus fils en C

Aller au menu
Aller à la recherche
Aller au contenu
Aller à la navigation

Partenaires

Rechercher

Accueil > Le LPNHE > Pages du personnel permanent > Beau Tristan > Divers > Vielleries > fork, ou comment créer des processus fils en C

fork, ou comment créer des processus fils en C

13 octobre 2005

par Tristan Beau - 18 mai 2017

La fonction fork permet de créer un nouveau processus.
Autrement dit, l’appel à fork crée un processus copie conforme du processus appelant.

Utilisation illustrative

Ainsi, vous pouvez essayer :

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

int main()
{
  int i;

  printf("Dans le corps du programme.\n");

  i=fork();

  printf("Apres le fork, i=%d\n",i);

  return 0;
}

L’exécution donnera :

Dans le corps du programme.
Apres le fork, i=6652
Apres le fork, i=0

Le premier printf est exécuté une fois, il se situait avant le fork.
En revanche, après l’appel à fork, le printf est appelé deux fois.

Il faut ensuite savoir que la valeur de retour de fork est :

soit 0, auquel cas nous sommes dans le processus fils
soit un nombre supérieur à 0, auquel cas nous sommes dans le processus parent, et le nombre correspond au PID du processus fils
soit -1 si il a été impossible de créer un nouveau processus (voir man 2 fork pour plus de détail.

Interaction minimale entre processus parent et fils

Pour effectuer des synchronisation entre processus parent et fils, on peut faire en sorte que le processus parent attende la fin du processus fils. On réalise cela ainsi :

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

int main()
{
  int i;
  int from_child[2];
  int to_child[2];
  int tochild,fromchild;

  /* ----------- Forking a child -------------*/
  if ( (i=fork() ) ) {
    if (i<0) {
      perror("Process cannot be forked");
      exit(errno);
    }
    /* ----------- Parent --------------------*/
    printf("Parent. It knows the child id = %d\n",i);
    
    printf("Parent. Waiting for child to die.\n");
    waitpid( i , NULL , 0 ) ;
    printf("Parent. Now let's continue.\n");
  }
  /* ------------- Child ---------------------*/ 
  else {  //In the child
    printf("Child. Wait 2 seconds.\n");
    sleep(2);
    printf("Child. Wait is over.\n");
  }

  printf("...the end.\n");

  return 0;
}

Essayez cela, l’exécution est très explicite :

on crée un processus fils (avec fork bien entendu)
le processus parent attend que le processus fils finisse (avec waitpid, sachant que le PID du processus fils a été donné par la valeur de retour de fork)
pour simuler un processus non trivial, on fait attendre 2 secondes le processus fils, qui meurt ensuite (et le précise en sortie standard)
le processus fils étant fini, le processus parent reprend et se termine.

Voilà !

Échange de données entre processus parent et fils

Avec l’utilisation de tuyaux (ou pipe en anglais), il est très simple de faire communiquer le processus parent et le processus fils. Ainsi, pour échanger des caractères (ici seulement 1 caractère), on pourra faire :

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

int main()
{
  pid_t child_pid;
  int from_child[2];
  int to_child[2];
  int tochild,fromchild;

  /* ----------- Creating Pipes -------------*/
  if ( pipe(from_child) || pipe(to_child) ) {
    perror("Cannot create pipes");
    exit(errno);
  }

  /* ----------- Forking a child -------------*/
  if ( (child_pid=fork() ) == -1 ) {
    perror("Process cannot be forked");
    exit(errno);
  }

  if ( child_pid ) {
    char c='p';
    /* ----------- Parent --------------------*/
    printf("Parent. It knows the child id = %d\n",child_pid);
    
    close(from_child[1]); 
    close(to_child[0]);
    
    if ( write(to_child[1],&c,1) != 1 ) {
       perror("Parent : cannot write to child");
       exit(errno);
     }

    if ( read(from_child[0],&c,1) != 1 ) {
      perror("Parent : cannot read from child");
      exit(errno);
    }
    
    printf("Parent : got character '%c' from child.\n",c);
  }
  /* ------------- Child ---------------------*/ 
  else {  
     char c;

    close(from_child[0]);
    close(to_child[1]);
    
    if ( read(to_child[0],&c,1) != 1 ) {
      perror("Child : cannot read from parent");
      exit(errno);
    }

    printf("Child : got character '%c' from parent\n",c);
   
    c = 'c';
    if ( write(from_child[1],&c,1) != 1 ) {
      perror("Child : cannot write to parent");
      exit(errno);
    }

  }

  return 0;
}

Dans la même rubrique :