Question

Simple edition: In a C++ program I’m using two different threads to work with some integer variable. but I’m sure one is always writing some value into it and the other one is only reading That. do I still need to use mutex lock when reading/writing data?

Now details : The main idea is that first thread generates some information and saves them into an array, and the second thread reads data from that array and process them. this array represents a queue. meaning I have two index values pointing to the first and last item in queue. Now I’m wondering if I have to lock these two index values whenever I’m reading or writing values or is it ok to check them without locking? note that generator thread is the only thread changing index of queue_back, and processor thread has exclusive permission to change queue_front.

if makes any change I’m developing for a linux based system and the code is compiled using gcc.

PS: In some codes which use threading, I’ve seen keyword volatile around variables shared between different threads, do I need to use that too?

Answer 1

No the read and write are not atomic, You will need to synchronize it using some synchronization mechanism.

Also, You MUST mark the shared integer as volatile, otherwise the optimizer might think the variable is never updated in one of your threads.

gcc allows you to do atomic operations on int‘s, long‘s and long long‘s (and their unsigned counterparts).

Look up for the functions:

type __sync_fetch_and_add (type *ptr, type value);
type __sync_fetch_and_sub (type *ptr, type value);
type __sync_fetch_and_or (type *ptr, type value);
type __sync_fetch_and_and (type *ptr, type value);
type __sync_fetch_and_xor (type *ptr, type value);
type __sync_fetch_and_nand (type *ptr, type value);