Qui s'exécute en premier, après le fork(): le parent ou l'enfant?

En général, rien ne peut être dit à propos de l'ordre relatif de leur exécution.

Maintenant, considérons votre problème spécifique. Si:

1. à la fois les processus de prendre un montant non négligeable de temps à courir, et
2. vous êtes en train de dire que l'on effectue un cycle complet avant de l'autre rend tout progrès, et
3. il y a inutilisé de cycles CPU, et
4. ce qui se passe à chaque fois que vous exécutez l'application.

Probablement cela indique qu'il existe certains (peut-être involontaire) de synchronisation entre les deux processus.

Si vous appelez vfork alors presque toutes les implémentations de définir que l'enfant sera exécuté en premier et ensuite parent va s'exécuter.(Jusqu'enfant demande exec).Donc, vous remarquerez l'exécution de série en cas de vfork indépendamment de schedular.Cependant, quand une fourche est simplement appelé deux nouveaux processus sont créés.Ils sont libres de fonctionner de façon indépendante.(Juste comme tout autre processus). Le processus qui s'exécute en premier sera fortement dépendante de l'algorithme d'ordonnancement. Côté algorithme d'ordonnancement le nombre de processus en cours d'exécution à ce moment permettra également de déterminer la nature de la production.D'ailleurs si vous êtes en utilisant le standard de la bibliothèque de fonctions d'e/s les données de sortie en rafales(sans doute pas le bon mot). Qui permettra également de déterminer dans une certaine mesure, qui se met à écrire en premier. Voici un exemple de code(Qui n'a pas beaucoup de sens pratiquement, mais encore un bon exemple de le parent et l'enfant à effet de fonctionner en synchronisme

  #include<stdio.h>
  #include<string.h>
  static void charAtTime(char buff[])
{
char *p=buff;
while(*p) {
putc(*p,stdout);
(p++);
}

}
    int main()
{
setbuf(stdout,NULL);   //set output stream to be unbuffered.Now each process will try to throw chars as soon as they are ready
int pid;
char buff[1000];
if((pid=fork())<0)   //First fork
    {
    fprintf(stderr,"Fork error\n");
    }
else if(pid==0)
    {
    strcpy(buff,"i am the child.I love beyblade.I love anime.I love pokemon\n");
   charAtTime(buff);    
  }
   else {
     int pid2=fork();   //secnd fork
     if(pid2==0){
     strcpy(buff,"I am the younger child\n");
         charAtTime(buff);
        }
   else {
int pid3;
pid3=fork();    //third fork
if(pid3==0)
    {
    strcpy(buff,"I am from the 2nd generation\n");
    charAtTime(buff);
    }
     else {
    strcpy(buff,"Our family tree is bit confusing\n");
    charAtTime(buff);
    }
        }

     strcpy(buff,"I am the big daddy of them.I have the right before them\n");
    }

   return 0;
    }

Pour mon système, la sortie suivante vient

   i am thOeI u ra cmfha mtihley  yoIturne geea rmi  cshf irblodimt
   thceo i2nnlfdd .uIg elnseoivrnea gb
   teiyobnl
   ade.I love anime.I love pokemon   

Toutefois, si de réduire le nombre de fourchettes à deux(Seulement deux processus concurrents), alors la sortie est moins moche.Son le parent qui s'exécute en premier.(Probablement à cause de ses processus en cours d'exécution lorsque l'autre processus est créé)

Que les autres réponses, vous ne pouvez pas le savoir, et vous ne devriez pas compter sur elle.

Mais, historiquement, sur Linux, parent contiune à exécuter, et après cela, les enfants. Sur un ancien Noyau Linux, il a été mis en œuvre le contraire manière: exécutant rapidement les enfants, qui seront probablement appel à un exec. De cette manière il n'y aura pas de copie sur écriture de la mémoire (ce qui devrait être fait à chaque écriture de parent). Devinez quoi? Que les changements cassé de nombreux outils de manière subtile (et difficile à déboguer), de sorte qu'il a été repris. Une perte de l'optimisation!.

Donc pas de relais sur le processus qui sera exécuté en premier.