web-dev-qa-db-fra.com

Que renvoie exactement Fork?

En cas de succès, le PID du processus enfant est renvoyé dans le thread d'exécution parent et un 0 est retourné dans le thread d'exécution enfant.

p = fork();

Je suis confus sur sa page de manuel, est p égal à 0 ou PID?

clinuxfork
22
compiler

Je ne sais pas comment le manuel peut être plus clair! fork() crée un nouveau processus, vous avez donc maintenant deux processus identiques. Pour les distinguer, la valeur de retour de fork() diffère. Dans le processus d'origine, vous obtenez le PID du processus enfant. Dans le processus enfant, vous obtenez 0.

Donc, une utilisation canonique est la suivante:

p = fork();
if (0 == p)
{
    // We're the child process
}
else if (p > 0)
{
    // We're the parent process
}
else
{
    // We're the parent process, but child couldn't be created
}
51
Oliver Charlesworth
 p = fork (); 
/* ne suppose aucune erreur */
/* vous avez maintenant deux programmes */
/* exécutant */
 -------------------- 
 si (p> 0) {| if (p == 0) {
 printf ("parent\n"); | printf ("enfant\n"); 
 ... | ...
29
pmg

Une fois que fork est exécuté, vous avez deux processus. L'appel renvoie des valeurs différentes à chaque processus.

Si vous faites quelque chose comme ça

int f;
f = fork();
if (f == 0) {
  printf("I am the child\n");
} else {
  printf("I am the parent and the childs pid is %d\n",f);

}

Vous verrez les deux messages imprimés. Ils sont imprimés par deux processus distincts. C'est de cette façon que vous pouvez différencier les deux processus créés.

8
Noufal Ibrahim

Les processus sont structurés dans un arbre dirigé où vous ne connaissez que votre parent seul (getppid()). En bref, fork() renvoie -1 En cas d'erreur comme de nombreuses autres fonctions système, une valeur non nulle est utile pour que l'initiateur de l'appel fork (le parent) connaisse son pid nouveau-enfant.

Rien n'est aussi bon que l'exemple:

/* fork/getpid test */
#include <sys/types.h>
#include <unistd.h>     /* fork(), getpid() */
#include <stdio.h>

int main(int argc, char* argv[])
{
    int pid;

    printf("Entry point: my pid is %d, parent pid is %d\n",
           getpid(), getppid());

    pid = fork();
    if (pid == 0) {
        printf("Child: my pid is %d, parent pid is %d\n",
               getpid(), getppid());
    }
    else if (pid > 0) {
        printf("Parent: my pid is %d, parent pid is %d, my child pid is %d\n",
               getpid(), getppid(), pid);
    }
    else {
        printf("Parent: oops! can not create a child (my pid is %d)\n",
               getpid());
    }

    return 0;
}

Et le résultat (bash est pid 2249, dans ce cas):

Entry point: my pid is 16051, parent pid is 2249
Parent: my pid is 16051, parent pid is 2249, my child pid is 16052
Child: my pid is 16052, parent pid is 16051

Si vous avez besoin de partager certaines ressources (fichiers, parent pid, etc.) entre parent et enfant, regardez clone() (pour GNU bibliothèque C, et peut-être d'autres)

8
levif

Ceci est la partie cool. C'est égal aux DEUX.

Eh bien pas vraiment. Mais une fois que fork revient, vous avez maintenant deux copies de votre programme en cours d'exécution! Deux processus. Vous pouvez en quelque sorte les considérer comme des univers alternatifs. Dans l'un, la valeur de retour est 0. Dans l'autre, c'est le ID du nouveau processus!

Habituellement, vous aurez quelque chose comme ça:

p = fork();
if (p == 0){
    printf("I am a child process!\n");
    //Do child things
}
else {
    printf("I am the parent process! Child is number %d\n", p);
    //Do parenty things
}

Dans ce cas, les deux chaînes seront imprimées, mais par des processus différents!

4
Chris Cooper

Fork crée un processus en double et un nouveau contexte de processus. Lorsqu'il renvoie une valeur 0, cela signifie qu'un processus enfant est en cours d'exécution, mais lorsqu'il renvoie une autre valeur, cela signifie qu'un processus parent est en cours d'exécution. Nous utilisons généralement une instruction d'attente pour qu'un processus enfant se termine et que le processus parent commence à s'exécuter.

1
mannukaushikece

fork() est invoquée dans le processus parent. Ensuite, un processus enfant est généré. Au moment où le processus enfant apparaît, fork() a terminé son exécution.

À ce stade, fork() est prêt à être renvoyé, mais il renvoie une valeur différente selon qu'il s'agit du parent ou de l'enfant. Dans le processus enfant, il renvoie 0 et dans le processus/thread parent, il renvoie l'ID de processus enfant.

1
BoltClock

Je pense que cela fonctionne comme ceci: lorsque pid = fork (), le code doit être exécuté deux fois, l'un est dans le processus en cours, l'autre dans le processus enfant. Cela explique donc pourquoi si/sinon les deux s'exécutent. Et l'ordre est, d'abord le processus en cours, puis exécutez l'enfant.

0
arswt