在C ++中所有并行线程中的所有锁定和解锁实例均使用相同的std :: mutex和lock对象

Question

I've 2 threads which access a shared resource:

Shared resource is the below Doubly linked list:

std::list<RowColumns> ll;
struct RowColumns
{
   int x;
   float y;
   vector<vector<string> vec2D;
   .....//many other fields;
}

Thread1: Writes data to this shared resource.

Thread 2: Reads data from this shared resource and writes to a file.

Both threads run in parallel ie as and when data is written to shared resource by Thread1 , then thread2 should keep reading the data written and write it to a file, for every "X" time interval. So, the code of T1 & T2 has many statements where shared resource is accessed. So to avoid hijacking of the shared resource by 1 thread I just lock & unlock for every acess so that I can achieve concurrency and both threads get opportunity to run.

My query is can I use a same mutex variable everywhere for all instances of locking and unlocking. Example to make my question more clear:

In below example, as you can see, the same mutex object "singleMutex" is used & also the same "lock1" unique_lock() lock object is used in both T1 & T2 threads for all acceses of the different elements of the shared resource. Will Such usage of using the same mutex & the same lock across all lock & unlock instances work & really serve the mutex purpose ? As we know mutex variable & lock is not attached to any object or resource, i think it should work. BUt at the same time I was confuse dbecause, if we use same mutex everywhere then where do we need multiple mutextx ?

    std::mutex singleMutex;


Thread1():
{
      RunStatement_WITH_NO_SHARED_RESOURCE ();
      while(someCondition())
      {
          std::unique_lock<std::mutex> lock1(singleMutex);
          RunStatement_ACCESSING_SHARED_RESOURCE();
          lock1.unlock();
          RunStatement_WITH_NO_SHARED_RESOURCE ();
          RunStatement_WITH_NO_SHARED_RESOURCE ();
          RunStatement_WITH_NO_SHARED_RESOURCE ();
          lock1.lock();
          RunStatement_ACCESSING_SHARED_RESOURCE();
          lock1.unlock();
      }
       RunStatement_WITH_NO_SHARED_RESOURCE ();
       RunStatement_WITH_NO_SHARED_RESOURCE ();
       RunStatement_WITH_NO_SHARED_RESOURCE ();
       std::unique_lock<std::mutex> lock1(singleMutex);
       RunStatement_ACCESSING_SHARED_RESOURCE();
       lock1.unlock();
       RunStatement_WITH_NO_SHARED_RESOURCE ();
       lock1.lock();
       RunStatement_ACCESSING_SHARED_RESOURCE();
       lock1.unlock();

       RunStatement_WITH_NO_SHARED_RESOURCE ();
       RunStatement_WITH_NO_SHARED_RESOURCE ();
       RunStatement_WITH_NO_SHARED_RESOURCE ();
       lock1.lock();
       RunStatement_ACCESSING_SHARED_RESOURCE();
       lock1.unlock();

Thread_2():

{
      RunStatement_WITH_NO_SHARED_RESOURCE ();

      std::unique_lock<std::mutex> lock1(singleMutex);
      RunStatement_ACCESSING_SHARED_RESOURCE();
      lock1.unlock();
      RunStatement_WITH_NO_SHARED_RESOURCE ();
      RunStatement_WITH_NO_SHARED_RESOURCE ();
      RunStatement_WITH_NO_SHARED_RESOURCE ();
      lock1.lock();
      RunStatement_ACCESSING_SHARED_RESOURCE();
      lock1.unlock();

      RunStatement_WITH_NO_SHARED_RESOURCE ();
      RunStatement_WITH_NO_SHARED_RESOURCE ();
      RunStatement_WITH_NO_SHARED_RESOURCE ();

      RunStatement_ACCESSING_SHARED_RESOURCE();
      lock1.unlock();
      RunStatement_WITH_NO_SHARED_RESOURCE ();
      lock1.lock();
      RunStatement_ACCESSING_SHARED_RESOURCE();
      lock1.unlock();

      RunStatement_WITH_NO_SHARED_RESOURCE ();
      RunStatement_WITH_NO_SHARED_RESOURCE ();
      RunStatement_WITH_NO_SHARED_RESOURCE ();
      lock1.lock();
      RunStatement_ACCESSING_SHARED_RESOURCE();
      lock1.unlock();

Answer 1

I am not sure if you really understand the concept of a mutex..

A mutex ( mut ual ex clusion) is used to lock the access on a shared resource, eg an integer, a list or any object. Even if your resource consists of multiple variables, you only need one mutex.

A good practice is to encapsulate the access on the resource in a function, so you only need to implement the mutex locking once per access function:

#include <mutex>

int g_resource = 42;
std::mutex g_mutex;

int getResource()
{
    std::lock_guard<std::mutex> lock(g_mutex);
    return g_resource;
    // auto unlocking, when object 'lock' is destroyed on exit of block
}

void incrementResource()
{
    std::lock_guard<std::mutex> lock(g_mutex);
    g_resource++;
}

//...

---

• For primitive datatypes I suggest using std::atomic<T>