CODEWITHSUNDEEP
c++multithreading
MRebai
MRebai

Reputation: 5474

Synchronize threads using mutex

I'm trying to understand C++ Multithreading and synchronize between many threads. Thus I created 2 threads the first one increments a value and the second one decrements it. what I can't understand why the resulted value after the execution is different than the first one, since I added and subtracted from the same value.

static unsigned int counter = 100;
static bool alive = true;
static Lock lock;
std::mutex mutex;

void add() {
    while (alive)
    {
        mutex.lock();
        counter += 10;
        std::cout << "Counter Add = " << counter << std::endl;
        mutex.unlock();
    }
}

void sub() {
    while (alive)
    {
        mutex.lock();
        counter -= 10;
        std::cout << "Counter Sub = " << counter<< std::endl;
        mutex.unlock();
    }
}

int main()
{
    std::cout << "critical section value at the start " << counter << std::endl;
    std::thread tAdd(add);
    std::thread tSub(sub);
    Sleep(1000);
    alive = false;
    tAdd.join();
    tSub.join();
    std::cout << "critical section value at the end " << counter << std::endl;

    return 0;
}

Output

critical section value at the start 100

critical section value at the end 220

So what I need is how to keep my value as it's, I mean counter equal to 100 using those two threads.

Upvotes: 0

Views: 2245

Answers (2)

cdonat
cdonat

Reputation: 2822

I think, what you want is to signal to the subtracting thread, that you just have sucessfully added in the add thread, and vice versa. You'll have to additionally communicate the information, which thread is next. A naive solution:

bool shouldAdd = true;

add() {
  while( alive ) {
    if( shouldAdd ) {
      // prefer lock guards over lock() and unlock() for exception safety
      std::lock_guard<std::mutex> lock{mutex};
      counter += 10;
      std::cout << "Counter Add = " << counter << std::endl;
      shouldAdd = false;
    }
  }
}

sub() {
  while( alive ) {
    if( !shouldAdd ) {
      std::lock_guard<std::mutex> lock{mutex};
      counter -= 10;
      std::cout << "Counter Sub = " << counter << std::endl;
      shouldAdd = true;
    }
  }
}

Now add() will busy wait for sub() to do its job before it will try and acquire the lock again.

To prevent busy waiting, you might chose a condition variable, instead of trying to only use a single mutex. You can wait() on the condition variable, before you add or subtract, and notify() the waiting thread afterwards.

Upvotes: 1

Catalin
Catalin

Reputation: 474

The problem is that both threads will get into an "infinite" loop for 1 second and they will get greedy with the mutex. Do a print in both functions and see which thread gets the lock more often.

Mutexes are used to synchronize access to resources so that threads will not read/write incomplete or corrupted data, not create a neat sequence.

If you want to keep that value at 100 at the end of execution you need to use a semaphore so that there will be an ordered sequence of access to the variable.

Upvotes: 2

Related Questions