严格使用 mutex_lock 和 mutex_unlock 在 2 个线程之间切换作为学术练习

Question

Hello everyone,

I am stuck with a mutex logic issue. I am using mutexes to switch between/synchronize two threads.

Thread one is required to read part of a file and then update a global var. It then switches to thread two which does a task and then returns to thread one to continue reading the next part of the file.

In main I am using sleep to force the first thread to execute. So far so good, After entering the first thread I update the variable in the critical section and the remain stuck inside thread 1 not switching to thread 2. Thread 2 is only entered after the thread 1 has run twice and we are at the second integer in the input file. Any advice on where my logic is wrong here would be appreciated. Thank you.

Output:

in thead 1
inside t1 while loop
inside critical section
Thread 1 updated GlobalVar to: 1 
inside t1 while loop
inside critical section
Thread 1 updated GlobalVar to: 2 
Thread 2:

//struct to pass file to thread 2
struct THEAD_TWO_DATA{
    FILE *outputFile;
}; 

pthread_mutex_t m1_lock = PTHREAD_MUTEX_INITIALIZER; // declaring mutex
pthread_mutex_t m2_lock = PTHREAD_MUTEX_INITIALIZER; // declaring mutex
int globalValue = 0;
int count = 0;

void* ThreadOne(void *param){
    printf("in thead 1\n");
    int value1;
    FILE *inputFile;  
    inputFile = fopen("hw3.in", "r");
    while (!feof (inputFile)){
        printf("inside t1 while loop\n");
        printf("inside critical section\n");
        pthread_mutex_lock(&m2_lock);
        fscanf (inputFile, "%d", &value1);
        globalValue = value1;
        printf("Thread 1 updated GlobalVar to: %d \n",globalValue);
        pthread_mutex_lock(&m1_lock);
        pthread_mutex_unlock(&m2_lock);
        count++;
    }
    printf("out of thread one loop\n");
    fclose (inputFile);
    pthread_exit(NULL);
}

void* ThreadTwo(void *received_struct){ 
    struct THEAD_TWO_DATA *struct_ptr = (struct THEAD_TWO_DATA*) received_struct;
    printf("Thread 2:\n");
    for (int i=0; i < count; i++){
        pthread_mutex_lock(&m1_lock);
        int r = globalValue % 2;
        if (r == 0){ // even
            fprintf(struct_ptr->outputFile, "%d\n", globalValue);
            fprintf(struct_ptr->outputFile, "%d\n", globalValue);
            printf("twice becase it is even\n");
            pthread_mutex_lock(&m2_lock);
        }
        else{
            fprintf(struct_ptr->outputFile, "%d\n", globalValue);
            printf("Once because it is odd\n");
            pthread_mutex_lock(&m2_lock);
        }
        pthread_mutex_unlock(&m1_lock);
    }
    pthread_exit(NULL);
}

int main(){
    pthread_t th[2];
    pthread_mutex_init(&m1_lock, NULL);
    pthread_mutex_init(&m2_lock, NULL);

    pthread_create(&th[0], NULL, ThreadOne, NULL);
    sleep(1);
    pthread_create(&th[1], NULL, ThreadTwo, &my_Struct);

    pthread_join(th[0], NULL);
    pthread_join(th[1], NULL);

    pthread_mutex_destroy(&m1_lock);
    pthread_mutex_destroy(&m2_lock);

    return 0;
}

Answer 1

Let main() initialize normal "fast" mutexes with mutex 2 pre-locked. Then start both threads, start order doesn't matter and there's no reason to sleep.

Each thread waits for its own mutex, does its thing, then unlocks the OTHER mutex and goes back to waiting for its own mutex again.

Since mutex 2 is initially locked, it will wait for thread 1 to unlock it. Then thread 1 will wait for thread 2 to unlock it, etc.

When thread 1 finally reads EOF it sets a kamikaze flag for thread 2 and unlocks it one final time, then exits. Thread 2 sees the flag and also exits.