C ++ pthread，两个线程读取一个全局变量

Question

如果有两个线程只读取全局变量，是否有必要使用互斥锁来锁定和解锁全局变量？

Answer 1

If the threads are only reading the variable and nobody is writing to it (not one of the threads, not someone else), then you're perfectly fine without locks. If any concurrent modification could happen, then everyone (including pure readers) must be synchronised somehow - by a mutex, a read/write lock or in some other way.

Answer 2

In general, exclusive access is required to prevent one from seeing an inconsistent state . For a reader thread, this means avoiding partial reads .

What does that mean ? Imagine that you have a value stored on two (atomic) integers, for example coordinates.

int i = 3;
int j = 4;

Now, we are going to read i and j whilst they undergo modification, more precisely when a Writer thread want to move in a diagonal fashion from (3, 4) to (4, 5) :

Reader     Writer
  |          |
  |        i = 4
  |          |
i = 4     <pause>
j = 4        |
  |        j = 5
  |          |

This is called a partial read : the Reader thread has gotten information that the object is at (4, 4) even though it was never there . I'll let you think what occurs if those coordinates are used to compute the trajectory of a plane...

Avoiding partial reads however is fairly easy: mutations should be seen atomically.

• if there is no mutation (for the duration of the reads) then you can just read
• if there are mutations, you need a mutual exclusion mechanism (such as a reader/writer mutex)

And thus, to answer your question, if the only accesses are read accesses, the no synchronization is required. But if you sometimes (even infrequently) modify the information read, then you need some mechanism.

Answer 3

如果他们只是阅读，那么你不需要锁定。

Answer 4

If they are just reading then no need of lock but when that is not the case then I think mutex will ensure that reading thread will not eat resources while it has nothing to do.

Something like this:-

Thread1() {
Mutex_lock();
Process global_variable;
Unlock_mutex();
}

Similarly for Thread2

On a side note:-

Mutex is generally used to prevent multiple threads from accessing shared memory or other resources concurrently. Also to remember that it does not lock anything by itself