C Gabel Umgang mit der globalen variable

Ich bin nicht zu verstehen, die Ausgabe dieses Programms:

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

int i = 0;

int main()
{
    while(i<3)
    {
        fork();

        printf("%d\n",i);
        ++i;
    }
}

Ausgabe:

0
1
2
2
1
2
0
1
2
2
2
1
2
2

Kann bitte mir jemand sagen, wie ich dieses Problem angehen, um vollständig zu verstehen, warum ich immer diese Ausgabe?

  • Sie haven T erzählte Sie uns, was Ihnen nicht gefällt.
  • Ich mag nicht, weil ich nicht verstehen, wenn wir incrementig die Gabel auf den übergeordneten Prozess oder in der Kinder-Prozesse. Normalerweise, wenn wir wollen die Erhöhung der Kind-Prozess, die wir tun if(fork()==0)++i; aber wenn wir es tun Gabel wie diese, ich bekomme ein wenig verloren in der Mitte!
  • Als pro-Antwort: Kind Schritten von Kind, Eltern-Schritten Eltern, nie die twain meed.
InformationsquelleAutor Bruno | 2010-01-28
  1. 25

    Gabel wird eine Kopie des Prozesses. Eine unabhängige Kopie des Prozesses. Also, wenn Sie eine Globale variable enthält 3 zum Zeitpunkt Gabel, jede Kopie des Prozesses bekommt Ihre ganz eigenen 3. Und wenn Sie ändern, Ihre änderungen sind vollständig unabhängig voneinander.

    InformationsquelleAutor bmargulies
  2. 16

    Den code ändern, um diese und die Ausgabe sollte machen viel mehr Sinn:

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

int i = 0;

int main()
{
    while (i < 3)
    {
        fork();
        printf("pid = %d, i = %d\n", getpid(), i);
        ++i;
    }
    return 0;
}
    InformationsquelleAutor Paul R
  3. 5

    Wenn du fork () eine komplette Kopie des aktuellen Prozesses ist erstellt, die in Ihrem aktuellen Zustand. Dies bedeutet, dass Ihre ersten Prozess werden drei neue Verfahren, die in der Mitte der while-Schleife, mit i wird jeweils 0, 1 und 2, in jedem von Ihnen. Es wird auch drucken, seine eigenen Werte i.

    Jedes Ihrer Kinder wird weiterhin die Schleife von der fork() Aufruf von drucken aus seiner ersten i Wert inkrementiert und die Schleife. Dies bedeutet, dass Kinder 0-print-0, 1, und 2, und spawnen zwei neue Kinder, mit den "ursprünglichen" Werte der i 1 und 2. Kinder von 1 drucken 1 und 2 und spawn eine mehr Kindern, mit einem "initial" - Wert von i 2. Für Kinder von 2 drucken 2 und verlassen die Schleife.

    Wenn Sie weiterhin auf diese Argumentation kommen Sie zu dem Schluss, dass insgesamt zwei 0 vier 1-und acht 2 gedruckt werden. Aber, da die Reihenfolge der Ausführung hängt davon ab, wie das OS plant die gleichzeitige Prozesse, Sie können nicht garantiert auf der Bestellung gedruckt werden.

    InformationsquelleAutor R. Martinho Fernandes
  4. 3

    Versuchen Sie es mit pthreads-wenn Sie möchten, erstellen Sie einen thread innerhalb des Prozesses für die gleichzeitige Programmierung. Die Funktion, die Sie wollen, ist pthread_create und pthread_join für das Aufräumen später.

    Etwas wie dieses:

    #include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <malloc.h>


int i = 0;

void *threadFunc(void *arg) 
{
    printf("%d\n",i);
}

int main()
{
    int j = 0;  
    int returnValue = 0;
    pthread_t* myThread = (pthread_t*) calloc(3, sizeof(pthread_t));;

    while(i < 3)
    {

        returnValue = pthread_create(&myThread[i], NULL, threadFunc, NULL);
        printf("main thread: %d\n",i);
        i++;

    }


    for(j = 0; j < 3; j++)
    {
        pthread_join(myThread[j], NULL); 

    }

    return 0;
}

    Vielleicht aber auch nicht, abhängig von Ihren tatsächlichen Bedarf.

    InformationsquelleAutor
  5. 2

    Er ist so etwas wie...

     1 (main) instance, i = 0(unforked)
 fork() > 2 instances, with i's = 0(forked), and 0(forked)
0 output from main instance, increments its i, 2 instances with i = 1u, 0f
 main instance forks, there's 3 instances with i's 1f, 1f, 0f
1 output from main instance, increments its i, 3 instances with i = 2u, 1f, 0f
 main instance forks, there's 4 instances with i's 2f, 2f, 1f, 0f
2 output from main instance, increments its i, 4 instances with i = 3u, 2f, 1f, 0f
 main instance then dies, 3 instances with i = 2f, 1f, 0f
2 output from next instance, increments its i, 3 instances with i = 3u, 1f, 0f
 next instance then dies, 2 instances with i = 1f, 0f
1 output from next instance, increments its i to 2, 2 instances with i = 2u, 0f

    ...etc

    Den Auftrag, die Abläufe sind-Ausgabe, ist jedoch unbestimmt, so dass Sie wahrscheinlich nicht sehen Sie den genau gleichen output, jedes mal, und selbst wenn Sie es tun, ist nicht etwas, das Sie garantieren können.

    Wie gesagt, jeder Prozess hat seine eigene Globale 'ich', die es verfolgt, und sein Wert wird einfach der Wert der Verzweigung des Prozesses i an der Gabel.

    InformationsquelleAutor Tanzelax
Schreibe einen Kommentar