avec fork() pour faire 3 enfants de 1 parent en C (pas C++)

Salut à tous, je travaille sur un programme qui fourches enfants et plus tard sera de fourche plus les enfants à partir de chaque enfant, mais ce n'est pas ce que j'ai besoin d'aide. Quand je lance mon programme (ici c'est une fonction, mais fonctionne de la même) je suis censé avoir un parent(PPID) spawn 3 enfants (PID= 1,2,3), mais ce que je reçois à est le même PID et PPID 3 fois (mon code actuel) ou avant je recevais 3 parents avec chacun des parents ayant un enfant et le PPIDS étaient différentes aussi bien que les PIDS, mais le PPIDs étaient tout de même que l'enfant précédent PIDs. Dans mes dernières tentatives, elle n'affiche jamais le parent(père) message au-dessus de l'enfant(fils). Il devrait ressembler à ceci

[dad] hi am I PID 1234 and I come from ####(dont care what this number is)
[son] hi i am PID 1111 and I come from PPID 1234
[son] hi i am PID 1112 and I come from PPID 1234
[son] hi i am PID 1113 and I come from PPID 1234

voici mon code. Je suis juste à la recherche de conseils si possible, sauf si c'est juste une stupide erreur que j'ai fait genre "oh il suffit de déplacer le fork() pour le processus de l'enfant" ou quelque chose comme ça.

Aussi, j'ai un child_count juste pour que je puisse facilement compter les enfants.

 int forking(null)
{
       void about(char *);
        int i=0;
        int j=0;
        int child_count =0;
        about("dad");

    for(i = 0; i < 3; i++ ){
        pid_t child = 0;
        child = fork();


            if (child < 0) { //unable to fork error
                    perror ("Unable to fork");
                    exit(-1);}

           else if (child == 0){ //child process
                    about ("son");
                    printf("I am child #%d \n",child_count);
                    child_count++;
                    exit(0);}

            else { //parent process (do nothing)

                }
            }

                for(j = 0; j < 3; j++ ){
                            wait(NULL);//wait for parent to acknowledge child process
                            }
return 0;
}

Deux choses à retenir: La première est que une fois que vous avez fourchue, le processus de l'enfant d'obtenir une copie de la mémoire de la mère, et lorsque l'enfant modifie par exemple les variables les variables sont modifiées que dans l'enfant, du parent (ou de "frères et sœurs") ne verrez pas ces la modification de la variable. La deuxième chose, c'est que vous appelez pour wait dans le else cas va bloquer parent et de l'enfant.
Oh, et vous avez un mauvais cas de la undefined behavior dans votre code. Vous définissez la child variable, mais vous l'utilisez avant initialisation. Non initialisé les variables locales ont un durée indéterminée de valeur, en les utilisant sans initialisation conduit à UB. Vous voudrez peut-être penser où vous appelez fork.
oh, vous voulez dire, comme pid_t enfant =0? Que voulez-vous dire wait() bloque à la fois le parent et l'enfant? Et à propos de la copie de la mémoire pourriez-vous me donner un exemple de code? Il est plus facile de voir ce point.
Concernant wait, vous l'appelez sans condition après l'appel à fork, de sorte qu'il sera appelé à la fois le parent et l'enfant. Si vous initialisez child à zéro, ce chemin d'accès le code de la prendre dans votre état? Et le processus ne partagent pas de mémoire, la mémoire dans un processus de ce processus, et que la mémoire comprend des variables comme child_count, de sorte que la modification d'une variable dans un processus n'aura pas la cause d'être modifiés à tout autre processus. Et encore une fois, pensez à ce que vous faites ou devrait le faire le fork appel.
Le while boucle à la fin doit être for(i=0;i<3;i++) boucle. Si vous mettez un printf dans le corps de la while boucle, vous verrez que ce n'est jamais parce que i est déjà 3 en raison de la précédente for boucle.

OriginalL'auteur Jite | 2015-09-29

Le parent doit

- imprimer un message

- appel de la fourche à trois reprises

- attendre que les trois enfants à la sortie

Chaque enfant doit

- imprimer un message

- sortie

Sorte que le code est aussi simple que

int main( void )
{
    printf( "[dad] pid %d\n", getpid() );

    for ( int i = 0; i < 3; i++ )
        if ( fork() == 0 )
        {
            printf( "[son] pid %d from pid %d\n", getpid(), getppid() );
            exit( 0 );
        }

    for ( int i = 0; i < 3; i++ )
        wait( NULL );
}

qui génère cette sortie

[dad] pid 1777
[son] pid 1778 from pid 1777
[son] pid 1779 from pid 1777
[son] pid 1780 from pid 1777

J'ai mis à jour. Comment est-ce?

OriginalL'auteur user3386109

2

La seule chose que vous devez retenir, c'est que, lorsque vous fork, à la fois le parent et l'enfant continuer l'exécution du code à ce point.

Donc, si vous ne faites pas l'enfant et le parent, la détection correctement, les enfants seront plus susceptibles de lancer leur propre enfants.

Un bon moyen pour vous de commencer à trois enfants et pas de petits-enfants est d'utiliser un compteur en conjonction avec le retour de l'ID de processus du fork appel, le long des lignes suivantes:
```
#include <stdio.h>
#include <unistd.h>

#define COUNT 3

int main(void) {
    # Desired and actual count.

    int count = COUNT, children = 0;

    //Force parent initially.

    pid_t retpid = 1;

    //Only fork if limit not reached AND is parent (children
    //  will exit loop with retpid == 0).

    while (count-- > 0 && retpid > 0)
        //Adjust actual count if successful.

        if ((retpid = fork()) > 0)
            children++;

    //Detect parent, all forks returned non-zero.

    if (retpid != 0) {
        printf("Parent %d spawned %d/%d children\n",
            getpid(), children, COUNT);

        //Wait for children to finish.

        while (children-- > 0)
            wait(NULL);
    } else {
        //Otherwise you were one of the children.

        printf("Child %d, sired by %d\n", getpid(), getppid());
    }

    return 0;
}
```
Ce sorties quels vous semblent être après si, en raison des caprices de la planification, non nécessairement dans cet ordre:
```
Parent 26210 successfully spawned 3/3 children
Child 26212, sired by 26210
Child 26213, sired by 26210
Child 26211, sired by 26210
```
La vérification du retour PID assurera seul le parent n'a aucune bifurcation, et le nombre de la limiter à une quantité spécifique.

Une chose que vous avez aussi besoin de regarder dehors pour est le tampon de sortie. Lorsque vous fourche, vous pouvez vous retrouver avec deux processus avec le tampon de sortie de données.

Où le périphérique de sortie peut être détecté comme un terminal, bouffées de chaleur auront normalement lieu sur un retour à la ligne en cours de sortie, de sorte que votre printf appels ne sera probablement pas dupliquer la sortie pour une course normale.

Vous avez juste besoin d'être conscient que vous pouvez obtenir intéressant résultats si vous rediriger la sortie vers un fichier, par exemple.

OriginalL'auteur paxdiablo

Vous devez vous connecter pour publier un commentaire.