CODEWITHSUNDEEP
cmultithreadingthread-safetypthreadsmutex
dragosb
dragosb

Reputation: 627

Mutex on pointers to a shared variable

I am new to thread programming. I know that mutexes are used to protect access to shared data in a multi-threaded program.

Suppose I have one thread with variable a and a second one with the pointer variable p that holds the address of a. Is the code safe if, in the second thread, I lock a mutex before I modify the value of a using the pointer variable? From my understanding it is safe.

Can you confirm? And also can you provide the reason why it is true or why it is not true?

I am working with c and pthreads.

Upvotes: 1

Views: 2894

Answers (1)

Filipe Gonçalves
Filipe Gonçalves

Reputation: 21213

The general rule when doing multithreading is that shared variables among threads that are read and written need to be accessed serially, which means that you must use some sort of synchronization primitive. Mutexes are a popular choice, but no matter what you end up using, you just need to remember that before reading from or writing to a shared variable, you need to acquire a lock to ensure consistency.

So, as long as every thread in your code agrees to always use the same lock before accessing a given variable, you're all good.

Now, to answer your specific questions:

Is the code safe if, in the second thread, I lock a mutex before I modify the value of a using the pointer variable?

It depends. How do you read a on the first thread? The first thread needs to lock the mutex too before accessing a in any way. If both threads lock the same mutex before reading or writing the value of a, then it is safe.

It's safe because the region of code between the mutex lock and unlock is exclusive (as long as every thread respects the rule that before doing Y, they need to acquire lock X), since only one thread at a time can have the lock.

As for this comment:

And if the mutex is locked before p is used, then both a and p are protected? The conclusion being that every memory reference present in a section where a mutex is locked is protected, even if the memory is indirectly referenced?

Mutexes don't protect memory regions or references, they protect a region of code. Whatever you make between locking and unlocking is exclusive; that's it. So, if every thread accessing or modifying either of a or p locks the same mutex before and unlocks afterwards, then as a side-effect you have synchronized accesses.

TL;DR Mutexes allow you to write code that never executes in parallel, you get to choose what that code does - a remarkably popular pattern is to access and modify shared variables.

Upvotes: 2

Related Questions