C ++，多线程环境中的全局数据行为

Question

I have an application running three threads. All three threads are doing some operations based on the status of a global variable. 2 of the threads are running the same piece of code and 1 thread is running another piece of code.

Ex:

Initial value of global variable is false

gGlobalVarLock = false;

thread 1:
while(true == gGlobalVarLock)
{
  /*wait for flag to become false*/
}
/*after the flag becomes false*/    
{
  mutex.lock();
  gGlobalVarLock = true;

  /*run some code*/

  gGlobalVarLock = false;
  mutex.unlock();
}

thread 2 and 3,    
while(true == gGlobalVarLock)
{
  /*wait for flag to become false*/
}
/*after the flag becomes false*/
{
  mutex.lock();
  gGlobalVarLock = true;

  /*run some other code*/

  gGlobalVarLock = false;
  mutex.unlock();
}

Now, after the application starts due to the init false value of gGlobalVarLock, one of the threads starts execution, and should lock the other threads from executing. As per my understanding the above implementation is somehow ensuring that the gGlobalVarLock is locked by the execution thread, and no other thread is getting access to it once the code under the mutex.lock() for any particular thread is executing. It looks like it is also locking the global variable under the lock. But I don't know how.

My code seems to be running fine. But I have one doubt. Mutex will lock the code for thread 2 and 3 since these two threads use the same piece of code for execution. But for the thread 1 which is running some other piece of code, how does the locking work? Does the mutex.lock() in that thread ensure that th gGlobalVarLock is locked for other threads when it is executing the code under its mutex.lock(). Does that mutex ensure the gGlobalVarLock is not changed my the other threads which are running some other piece of code? My understanding is mutex.lock() locks common code used by different threads. Then how is the global variable getting locked in my case where different threads are running different codes.

Does mutex.lock() lock global variables in a multi-threaded environment?

Answer 1

The point is precisely that if you create a mutex object in the parent process and share it between several threads, this object's memory is shared by the threads (those are not processes)

Should you create processes instead (using fork() ) the memory would be copied and it would not work.

But between threads, memory is shared so the object is shared. You have a single instance of mutex in memory for all your threads.

This object will ensure that only one thread at a time is accessing the critical section located between the calls of lock and unlock .

In a nutshell, your code is OK.

Answer 2

The mutex assures that after the lock() just the thread that acquires the mutex can execute the code until reach the unlock() call. Unless you have a code very slow, you can think it's being executing simultaneously. However the block of code between the lock() and unlock() is going to executed by just one thread each time.

Answer 3

A mutex does not lock variables, it only locks itself. By restricting access to a variable behind a mutex you can protect that variable, but if the variable is global, there is no guarantee that elsewhere in your code you might unintentionally access it without going through the mutex.

For example, in your code, nobody uses the mutex until they have already accessed the, global variable and found it to be false. So it is entirely possible that all three threads would contend for the mutex lock.

In your example, the global variable seems redundant, you seem to be using it as a filter to protect access to the mutex.

You may be looking for something called a condition variable to use in conjunction with your mutex.