Kooperativ mit Threads arbeiten (C)

Question

Aufgabe : Schreiben Sie ein Programm, welches mittels zwei Threads arbeitet. Beide sollten aufwechselnd eine variable jeweils um 1 erhöhen. Die main() soll beendet werden, wenn die wvariable 2000 erreicht und gestartet werden soll bei einem wert von -1000.

Unten ist mein Ansatz jedoch weiss ich nicht wie man den abwechselnden Vorgang von Threads schreibt. Ich habe es hinbekommen dass das eine Thread die "Hälfte" der arbeit erledigt und danach das 2. Thread den Rest tut. Mein Ansatz unten schlägt leider fehl und bräuchte Hilfe.

MFG.

#include <stdio.h>
#include <pthread.h>
#define NLOOP 1long int  Counter=0;
pthread_t tidA, tidB;  //Erstellen von Thread variablen
pthread_mutex_t counter_mutex=PTHREAD_MUTEX_INITIALIZER;   /*Mit Mutexes kann man Teile vom Sorce Code einklammern und somit bestimmten Zeitpunkten ungewollten Zugriff von andere Threads während der Operation schützen.*/

void *doit(void*vptr)
{
int i,j;

        for(i=0;i<NLOOP;i++){                             // Hier wäre der part wo ich die Hilfe bräuchte habe es mal so stehen lassen
                pthread_mutex_lock(&counter_mutex);
                Counter+=1;
                printf("Thread %u: %ld\n",(unsigned int)pthread_self(),Counter);
                pthread_mutex_unlock(&counter_mutex); /* Sperrt die Operation für andere Threads. Aber  arbeitet jedesmal ein random Thread daran? */
                }
        
return(NULL);
}


int main(void)
{
pthread_create (&tidA,NULL,doit,NULL);// Erstellen von zwei Threads
pthread_create (&tidB,NULL,doit,NULL);
pthread_join(tidA,NULL); // Sorgt dafür dass main wartet bis die threads fertig sind
pthread_join(tidB,NULL);//  same as above
return 0;
}

Answer 1

Ich habe gerade mehrere Tests Deines Codes durchgeführt (auch mit mehr als zwei Threads):

#include <stdio.h> 
#include <pthread.h> 
#define NLOOP 1
long int  Counter=0; 
pthread_t tidA, tidB, tidC,tidC,tidC,tidD,tidE,tidF,tidG,tidH,tidI,tidJ,tidK,tidL,tidM,tidN,tidO,tidP;  //Erstellen von Thread variablen 
pthread_mutex_t counter_mutex=PTHREAD_MUTEX_INITIALIZER;  /*Mit Mutexes kann man Teile vom Sorce Code einklammern und somit bestimmten Zeitpunkten ungewollten Zugriff von andere Threads während der Operation schützen.*/ 

void *doit(void*vptr) 
{ 
int i,j; 

        for(i=0;i<NLOOP;i++){                            // Hier wäre der part wo ich die Hilfe bräuchte habe es mal so stehen lassen 
                pthread_mutex_lock(&counter_mutex); 
                Counter+=1; 
                printf("Thread %u: %ld\n",(unsigned int)pthread_self(),Counter); 
                pthread_mutex_unlock(&counter_mutex); /* Sperrt die Operation für andere Threads. Aber  arbeitet jedesmal ein random Thread daran? */ 
                } 
        
return(NULL); 
} 


int main(void) 
{ 
pthread_create (&tidA,NULL,doit,NULL);
pthread_create (&tidB,NULL,doit,NULL); 
pthread_create (&tidC,NULL,doit,NULL); 
pthread_create (&tidD,NULL,doit,NULL); 
pthread_create (&tidE,NULL,doit,NULL); 
pthread_create (&tidF,NULL,doit,NULL); 
pthread_create (&tidG,NULL,doit,NULL); 
pthread_create (&tidH,NULL,doit,NULL); 
pthread_create (&tidI,NULL,doit,NULL); 
pthread_create (&tidJ,NULL,doit,NULL); 
pthread_create (&tidK,NULL,doit,NULL); 
pthread_create (&tidL,NULL,doit,NULL); 
pthread_create (&tidM,NULL,doit,NULL); 
pthread_create (&tidN,NULL,doit,NULL); 
pthread_create (&tidO,NULL,doit,NULL); 
pthread_create (&tidP,NULL,doit,NULL); 
pthread_join(tidA,NULL);
pthread_join(tidB,NULL);
pthread_join(tidC,NULL); 
pthread_join(tidD,NULL);
pthread_join(tidE,NULL);
pthread_join(tidF,NULL);
pthread_join(tidG,NULL);
pthread_join(tidH,NULL); 
pthread_join(tidI,NULL);
pthread_join(tidJ,NULL);
pthread_join(tidK,NULL);
pthread_join(tidL,NULL);
pthread_join(tidM,NULL);
pthread_join(tidN,NULL);
pthread_join(tidO,NULL);
pthread_join(tidP,NULL);
return 0; 
} 

Über \(1000\) Testläufe lieferten stets die korrekte Reihenfolge! Entfernt man den von Dir gesetzten Mutex und entzieht auf diese Weise der Critical Section ihren Schutz, so ist der Output (erwartungsgemäß) falsch (d. h. die Variablenwerte von Counter wird nicht in der richtigen Reihenfolge auf die Konsole gedruckt).

Für einen abwechselnden Vorgang hast Du die Wahl zwischen mehreren Optionen

- Priorisierung der Threads modifizieren.

- Identifizierung der Threads anhand ihrer ID und entsprechende Reaktion, falls ein Thread zweimal hintereinander inkrementieren möchte.