Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== C - C++ Threads - Protected access to shared data or shared resources - Mutex - Class Example ======

<code cpp>
#include <iostream>
#include <thread>
#include <vector>
#include<mutex>


// The Wallet Class provides a service to add money into a Wallet.
//
// The same Wallet object is used between different threads, so a Lock is needed in the addMoney() method of the Wallet.
//
// A lock is acquired before incrementing the money within the Wallet and the lock is released before leaving that function.
class Wallet
{
  int mMoney;
  std::mutex mutex;
  
public:
  Wallet() :mMoney(0){}
  int getMoney()   { return mMoney; }
  void addMoney(int money)
  {
    mutex.lock();
    for(int i = 0; i < money; ++i)
    {
      mMoney++;
    } 
    mutex.unlock();
  } 
};


// Five threads will share the same Wallet class object and each thread will add 1000 into the Wallet using the addMoney() member function in parallel.
//
// So, if initially the money in the wallet is 0, then then after completion of all the threads, the money in the Wallet should be 5000.
//
// Adding a mutex lock guarantees that Money in the Wallet will be 5000 at the end.
int testMultithreadedWallet()
{
  Wallet walletObject;
  std::vector<std::thread> threads;
  
  for(int i=0; i<5; ++i) 
  {
    threads.push_back(std::thread(&Wallet::addMoney, &walletObject, 1000));
  } 
  
  for(int i=0; i<threads.size() ; i++)
  {
    threads.at(i).join();
  } 
  
  return walletObject.getMoney();
} 


int main()
{
  int val = 0;
  for(int k=0; k<1000; k++)
  {
    if((val = testMultithreadedWallet()) != 5000)
    {
      std::cout << "Error at count = "<<k<<"  Money in Wallet = "<<val << std::endl;
      //break;
    } 
  } 

  return 0;
} 
</code>

<WRAP info>
**NOTE:**  The **mutex** lock in addMoney() makes sure that once one thread finishes the modification of money then only any other thread modifies the money in Wallet.
</WRAP>

<WRAP important>
**WARNING:**  What happens if for some reason a thread that has locked the addMoney() is unable to unlock the mutex at the end of the function?

  * Other threads will remain in waiting, and this will not be successful.
  * This kind of scenario can happen if some exception arose after locking the mutex.
  * To avoid such scenarios we should use **std::lock_guard**.
    * See the next note on std::lock_guard.
</WRAP>

----

===== std::lock_guard =====

**std::lock_guard** is a class template, which implements the RAII for mutex.

It wraps the mutex inside its object and locks the attached mutex in its constructor.

When its destructor is called it releases the mutex.

<code cpp>
class Wallet
{
  int mMoney;
  std::mutex mutex;

public:
  Wallet() :mMoney(0){}
  int getMoney()   { return mMoney; }
  void addMoney(int money)
  {
    std::lock_guard<std::mutex> lockGuard(mutex);
    // In constructor it locks the mutex.
    for(int i=0; i<money; ++i)
    {
      // If some exception occurs at this
      // point then the destructor of lockGuard
      // will be called due to stack unwinding.
      //
      mMoney++;
    }
    // Once the function exits, then the destructor
    // of the lockGuard Object will be called.
    // In the destructor it unlocks the mutex.
  }
};
</code>