Pthread nicht für Mutex-Sperre warten threadFinished

Question

Hallo unten ist mein Codierung Schnipsel

#include <pthread.h> 
#include <stdio.h> 
#include <unistd.h> 
#define TIMEOUT 3 
int threadFinished = 0; 
pthread_mutex_t g_mutex; 

void *threadFunction(void* attr) 
{ 
    pthread_mutex_lock(&g_mutex); 
    char *pData = (char*)attr; 
    if(pData) 
    { 
     printf("data from main thread is : %s\n",pData); 
    } 
    sleep(10); 
    threadFinished = 1; 
    pthread_mutex_unlock(&g_mutex); 
    return (void*)"This is thread message !"; 
} 

int main() 
{ 
    pthread_t tid; 
    char *retVal = NULL; 
    int iTimeOut = TIMEOUT; 
    int i =0; 
    pthread_mutex_init(&g_mutex,NULL); 
    pthread_create(&tid,NULL,threadFunction,"Message from main thread"); 

    //printf("itimeout %d , threadrunning %d\n",iTimeOut,threadRunning); 
    while(iTimeOut!=0 && !threadFinished) 
    { 
     printf("waiting %d\n",++i); 
     sleep(1); 
     iTimeOut--; 
     printf("changing the threadfinish varible\n"); 
     //pthread_mutex_lock(&g_mutex); //statement 1 
     threadFinished = 1; 
     //pthread_mutex_unlock(&g_mutex); // statement 2 
     printf("changed the threadfinish varible\n"); 
    } 

    if(iTimeOut==0) 
    { 
     if(!threadFinished) 
     { 
      printf("Timed out so cancelling the thread \n"); 
      pthread_cancel(tid); 
     } 
     else 
     { 
      printf("thread finished \n"); 
     } 
    } 
    else 
    { 
     printf("thread finished its job \n"); 
     pthread_join(tid,(void*)&retVal); 

    } 
    pthread_mutex_destroy(&g_mutex); 
    threadFinished = 0; 
    printf("message from thread is : %s\n",retVal); 
    return 0; 
} 

Wenn Anweisung1 & statement2 sind kommentierte ich Kind Thread erwarte, bevor Hauptthread meine testrunning Variable zu ändern, aber es funktioniert nur dann richtig, wenn statement1 und statement2 sind unkommentiert.
Meine Frage ist, warum in Kind Thread Mutex Sperre meine testrunning Variable nicht sperren. es erlaubt dem Haupt-Thread, die Variable testrunning zu ändern.

Answer 1

Wenn auf eine Variable gleichzeitig von mehreren Threads zugegriffen wird, muss jeder Thread den Zugriff darauf über denselben Mutex schützen. Der Thread main() schlägt fehl.

Um dies zu korrigieren Sie main() ‚s while-Schleife wie folgt ändern könnte:

while (iTimeOut != 0) 
    { 
    { 
     pthread_mutex_lock(&g_mutex); 
     int finished = threadFinished; 
     pthread_mutex_unlock(&g_mutex); 

     if (finished) 
     { 
     break; 
     } 
    } 

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

    sleep(1); 
    iTimeOut--; 

    printf("changing the threadfinish varible\n"); 

    pthread_mutex_lock(&g_mutex); //statement 1 
    threadFinished = 1; 
    pthread_mutex_unlock(&g_mutex); // statement 2 

    printf("changed the threadfinish varible\n"); 
    } 

Auch könnten Sie Sperren Verengung prüfen möchte, wo es in der Thread-Funktion wie dies erforderlich ist:

void *threadFunction(void* attr) 
{ 
    char *pData = attr; /* No need to cast here in C, as opposed to C++. */ 
    if(pData) 
    { 
    printf("data from main thread is : %s\n",pData); 
    } 
    sleep(10); 

    pthread_mutex_lock(&g_mutex); 
    threadFinished = 1; 
    pthread_mutex_unlock(&g_mutex); 

    return "This is thread message !"; /* No need to cast here in C, as opposed to C++. */ 
} 

Sie sollten allen Bibliotheksaufrufen eine Fehlerprüfung hinzufügen, falls ein Fehler die verbleibende Ausführung beeinflussen würde.