Exactement ce que fait la fourche de retour?

En cas de succès, le PID de l'enfant
le processus est retourné à la société mère
l'exécution du thread, et un 0 est
renvoyé de l'enfant à l'exécution du thread.

p = fork();

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

Quelqu'un peut-il inclure getpid() dans l'image? getpid() de l'enfant retourne 0?
Donc ne fork().
Il est à la fois pid et 0. Lorsque la fourche est appelé, le programme "divise" en deux, en lui-même et son double maléfique. Dans le programme d'origine, elle est de 0. Dans le jumeau maléfique du programme, c'est le pid.
Je crois qu'un fork retourne une petite portion de nourriture, mais je peux me tromper. 😉
Ce qu'il ya à être confus au sujet? La documentation que vous avez cité est tout à fait clair.

InformationsquelleAutor compiler | 2011-04-07

c fork linux

48

Je ne suis pas sûr de savoir comment le manuel peut être plus clair! fork() crée un nouveau processus, de sorte que vous avez maintenant deux identiques processus. Pour distinguer entre eux, la valeur de retour de fork() diffère. Dans le processus d'origine, vous obtenez le PID du processus fils. Dans le processus de l'enfant, vous obtenez 0.

Donc un canoniques comme suit:
```
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
}
```
- 0 signifie aussi pas de processus est créé,à droite?Sinon, les processus seront créés de manière récursive,ne jamais s'arrêter...
- non, les deux processus (l'ancien et le nouveau) de poursuivre l'exécution de après l'appel à fork.
- Sauer ,je ne veux pas de processus créer,ne pas dire sortie
- Il n'y a pas de récursivité. Comme @Joachim dit, le nouveau processus ne démarre pas à partir du début de la main, il porte sur directement après le fork() appel.
- Je thinkk votre exemple de code n'est pas clair, parce que vous appelez fourche à deux reprises (p = fork() et donc 0 == fork() à la ligne suivante). Aussi, il pourrait être bon d'y ajouter de la fourche peut également renvoyer -1 dans laquelle nous sommes encore dans le processus parent, comme aucun enfant ne pourrait être créé 😉
- Ah, oui, une faute de frappe! Bonne prise.
- Si aucun processus n'est créé, ce qui signifie fork impossible, de sorte qu'il retourne -1, pas 0, et définit errno de façon appropriée. Il le fait dans le processus d'origine (qui n'est pas un parent, car aucun processus n'a été créé).
- Un/ est-ce que le nouveau processus de commencer par le HAUT d'une nouvelle copie du script? Ou immédiatement au-dessous de la fourche déclaration? Comment faites-vous passer des valeurs à la fourche processus?
- Les enfants et les parents de continuer à compter à partir de l'appel à la fourchette. Il y a beaucoup de mécanismes pour la communication entre processus (tuyaux, Fifo, sockets, ...)
- Ce qui se passe pour le compteur de programme, lorsque nous fourche, d'où le compteur de programme, les points dans le processus de l'enfant lorsque nous fourche d'un nouveau processus?
- Il est répondu que, un an avant que vous avez demandé. les Deux parent et à l'enfant de continuer à compter à partir de l'appel à la fourchette.
InformationsquelleAutor Oliver Charlesworth

 p = fork(); 
/* supposons pas d'erreurs */
/* vous avez maintenant deux */
/* programmes en cours d'exécution */
-------------------- 
si (p > 0) { | if (p == 0) { 
printf("parent\n"); | printf("enfant\n"); 
... | ...

InformationsquelleAutor pmg

8

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

Si vous faites quelque chose comme cela
```
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 à la fois les messages imprimés. Ils sont imprimés par deux processus distincts. C'est la façon que vous pouvez faire la distinction entre les deux processus de création.
- Quand elle retourne 0,cela signifie fork ne pas créer un processus,non?
- Pas de. Cela signifie que vous êtes dans le processus de l'enfant. "Pas la création d'un processus" signifie qu'il n'y aura qu'un seul processus. Si un -1 est retourné, cela signifie qu'aucun enfant n'a été créé. La page de man indique ce.
- quand n'est-il pas de créer un enfant? si j'utilise fork() dans une boucle while , je ne serai jamais à être obtenir la valeur de -1?
- Peut être pour une raison quelconque. Le errno est définie si elle renvoie -1 de sorte que vous savez pourquoi il a échoué.
InformationsquelleAutor Noufal Ibrahim

Processus sont structurés dans un dirigé arbre où vous ne connaissez que votre monoparentale (getppid()). En bref, fork() retourne -1 sur erreur comme beaucoup d'autres fonctions du système, valeur non nulle est utile pour l'initiateur de la fourche à l'appel (le parent) de savoir son enfant pid.

Rien n'est aussi bon que 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 des ressources (fichiers, parent pid, etc.) entre le parent et l'enfant, regardez clone() (pour la bibliothèque C de GNU, et peut-être d'autres)

InformationsquelleAutor levif

4

C'est la partie la plus cool. Il est égal à DEUX.

Bien, pas vraiment. Mais une fois fork retourne, vous avez maintenant deux copies de votre programme en cours d'exécution! Deux processus. Vous pouvez sorte de penser à eux en tant que d'autres univers. Dans l'un, la valeur de retour est 0. Dans l'autre, c'est la ID de la nouvelle procédure!

Habituellement, vous aurez quelque chose comme ceci:
```
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 sera imprimée, mais par des procédés différents!
- Vous avez le parent/enfant vers l'arrière.
- Oups! Merci. Fixe.
- Également vérifier l'erreur (-1 == p).
InformationsquelleAutor Chris Cooper
1

fork() est invoquée dans le processus parent. Ensuite, un processus enfant est engendré. Par le temps que l'enfant processus génère, fork() a terminé son exécution.

À ce point, fork() est prêt à revenir, mais il renvoie une valeur différente selon qu'il s'agisse de la mère ou de l'enfant. Dans le processus de l'enfant, elle renvoie la valeur 0, et dans le processus parent/thread, il renvoie l'enfant de l'ID de processus.
- Voulez-vous dire fork évalue à NO Operation dans le processus de l'enfant?
- Dans ce cas, il a pas d'effets secondaires. Mais il ne retour différemment selon l'endroit où elle est invoquée.
- Pas de. La fourche s'exécute dans le parent, puis crée un supplément de processus. La valeur de retour de fork, seront différentes dans les deux processus de distinguer entre les deux.
- Ibrahim,je sais 0 moyen de l'enfant dans le processus,mais il signifie aussi, sans supplément de processus est créé?
- Si vous appelez fork la fois, un processus est créé. Je ne comprends pas votre question.
- Ibrahim: je pense que ma réponse a été mal formulée. Je l'ai montée, peut-être que ça a plus de sens maintenant.
- no: fourche retourne -1 si aucun processus n'est créé.
InformationsquelleAutor BoltClock
1

Fourche crée un double processus et un nouveau contexte de processus. Lorsqu'elle retourne une valeur de 0 signifie que l'enfant d'un processus est en cours, mais lorsqu'il renvoie à une autre valeur que signifie un processus parent est en cours d'exécution. Nous utilisons habituellement attendre déclaration pour qu'un enfant à la fin du processus et processus parent commence à s'exécuter.

InformationsquelleAutor mannukaushikece
0

Je pense que ça marche comme ça:
lorsque pid = fork(), le code doit être exécuté deux fois, on est dans le processus actuel, on est en processus enfant.
Donc, il explique pourquoi si/d'autre fois exécuter.
Et l'ordre est, premier processus actuel, et ensuite exécuter l'enfant.
- L'ordre n'est pas garanti (autant que je sache).
InformationsquelleAutor arswt

Vous devez vous connecter pour publier un commentaire.