Multi-thread. Undefined behaviour with two while loops in two different thread - c++

Question

#include <mutex>
using namespace std;
int counter = 0;
mutex m;
void thread1() {
while(1) {
m.lock();
cout << "th1 " << counter << endl;
++counter;
if (counter == 300) {
m.unlock();
break;
}
m.unlock();
}
}
void thread2() {
while(1) {
m.lock();
cout << "th2 " << counter << endl;
if (counter == 10) {
counter = 300;
m.unlock();
break;
}
m.unlock();
}
}
int main(int argc, const char * argv[]) {
thread th1(thread1);
thread th2(thread2);
th1.join();
th2.join();
return 0;
}
I'm running two threads with while loops. Why despite the fact that I use mutex lock and unlock result of this code is different every time.
First code from function thread1 is executed X-times, then code from function thread2 is executed y-times.
Shouldn't them be executed one after another .. thread1 -> thread2 -> thread1 -> etc ?

Answer 1

This is non-deterministic because you have a race condition.
Every time you unlock the mutex both threads race to lock it again.
Also in your code you can increment over 10 and miss the exit condition in thread2 which is not what I think you want.
One way you could sync the execution to be what you described (thread1, thread2, thread1, etc..) is by using a condition variable (std::condition_variable).
Here is your code with some slight modification to get the sync behavior:
#include <mutex>
#include <iostream>
using namespace std;
int counter = 0;
bool flag = false;
mutex m;
condition_variable c;
void thread1() {
while(1) {
unique_lock<mutex> lk(m);
c.wait(lk, []{ return flag; });
cout << "th1 " << counter << endl;
if (counter == 300) {
flag=!flag;
lk.unlock();
c.notify_one();
break;
}
counter++;
flag=!flag;
lk.unlock();
c.notify_one();
}
}
void thread2() {
while(1) {
unique_lock<mutex> lk(m);
c.wait(lk, []{ return !flag; });
cout << "th2 " << counter << endl;
if (counter == 10) {
counter = 300;
flag=!flag;
lk.unlock();
c.notify_one();
break;
}
flag=!flag;
lk.unlock();
c.notify_one();
}
}
int main(int argc, const char * argv[]) {
thread th1(thread1);
thread th2(thread2);
th1.join();
th2.join();
return 0;
}
And the output:
th2 0
th1 0
th2 1
th1 1
th2 2
th1 2
th2 3
th1 3
th2 4
th1 4
th2 5
th1 5
th2 6
th1 6
th2 7
th1 7
th2 8
th1 8
th2 9
th1 9
th2 10
th1 300
then the program exits...
A couple of notes:
The threads are sync'd on the bool flag variable.
flag is used to create the predicate used in the wait methods called on the conditional_variable
c.wait(lk, []{ return flag; });
which is just a lambda which returns the flag current value.
th1 triggers on flag==true and th2 on flag==false.
The notify_one method tells the waiting thread to check its condition.
And we use a unique_lock instance specifically because we need to be able to manually lock/unlock the lock based on the condition.