并发：使用pthread_mutex来雾化增量操作

Question

I'm currently reading Operating Systems: Three Easy Pieces and I'm starting to get the logic behind concurrency. In the 26 "chapter" we get this example of threads and the problems around atomicity:

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

static volatile int counter = 0;

// mythread()
// Simply adds 1 to counter repeatedly, in a loop
// No, this is not how you would add 10,000,000 to
// a counter, but it shows the problem nicely.

void *mythread(void *arg){
    printf("%s: begin\n", (char *) arg);
    int i;
    for (i = 0; i < 1e7; i++) {
        counter = counter + 1;
    }
    printf("%s: done\n", (char *) arg);
    return NULL;
}


// main()
// Just launches two threads (pthread_create)
// and then waits for them (pthread_join)

int main(int argc, char *argv[]) {
    pthread_t p1, p2;
    printf("main: begin (counter = %d)\n", counter);
    pthread_create(&p1, NULL, mythread, "A");
    pthread_create(&p2, NULL, mythread, "B");

    // join waits for the threads to finish
    pthread_join(p1, NULL);
    pthread_join(p2, NULL);
    printf("main: done with both (counter = %d)\n", counter);
    return 0;

}

And it shows us the issue is that because of the race condition in the increment the value of the sum varies and rarely is the supposed.

Per example, after compilling:

gcc -g -o main page6.c -Wall -pthread

and running twice I get:

main: begin (counter = 0)
A: begin
B: begin
A: done
B: done
main: done with both (counter = 10263001)

and:

main: begin (counter = 0)
A: begin
B: begin
A: done
B: done
main: done with both (counter = 10600399)

So after reading about mutex I tried this little change to the code in the mythread() function.

void *mythread(void *arg){
    pthread_mutex_t lock;
    int rc = pthread_mutex_init(&lock,NULL);
    assert(rc==0); //always check sucess

    printf("%s: begin\n", (char *) arg);
    int i;

    for (i = 0; i < 1e7; i++) {
        pthread_mutex_lock(&lock);
        counter = counter + 1;
        pthread_mutex_unlock(&lock);
    }

    printf("%s: done\n", (char *) arg);
    return NULL;
}

and after compiling (in the same way) and running, it does take noticeably more time (1-2 seconds).

But the results aren't any better:

main: begin (counter = 0)
A: begin
B: begin
B: done
A: done
main: done with both (counter = 10019830)

and:

main: begin (counter = 0)
A: begin
B: begin
B: done
A: done
main: done with both (counter = 10008806)

So why doesn't this work? Shouldn't this create a critical section in code? Am I missing something obvious?

Answer 1

You shouldn't have the mutex as a local variable in mythread since each thread then gets it's own copy. Make it global and initialize it in main.