Dekker Mutual-Exclusion - multithreading

Question

I'm studying the operating system and the program that Dekker wrote for his third attempt to Mutual Exclusion
I wrote my code in C ++ in Visual Studio, the code is below, but I wonder how these two threads are still in the critical area at the same time?
The output of the program is below
#include<iostream>
#include<conio.h>
#include<thread>
using namespace std;
bool flag0 = false;
bool flag1 = false;
void p1()
{
flag0 = true;
while (flag1);
for (int i = 1; i <= 10; i++)
cout << "p1 : " << i << endl;
flag0 = false;
}
void p2()
{
flag1 = true;
while (flag0);
for (int i = -1; i >= -10; i--)
cout << "p2 : " << i << endl;
flag1 = false;
}
int main()
{
thread t1(p1);
thread t2(p2);
t1.join();
t2.join();
_getch();
return 0;
}
Output:
p1 : p2 : -11
p2 : p1 : 2
p1 : 3
p1 : 4
p1 : 5
p1 : 6
-2
p2 : -3
p2 : -4
p2 : -5
p2 : -6
p2 : -7
p2 : -8
p2 : -9
p2 : p1 : -107
p1 : 8
p1 : 9
p1 : 10

Answer 1

" I wonder how these two threads are still in the critical area at the same time"
You've got two threads accessing the same variables, without any form of synchronization. In C++, that is a form of Undefined Behavior. Undefined Behavior means that anything can happen. "Two threads in the same critical area at the same time" is not even remotely surprising.

Answer 2

The problem is that your flags are ordinary bool variables, which results in a data race and therefore UB. That basically means that all bets are off about how your program behaves! For example, the compiler could hoist the load in the while-loop, effectively transforming the loop into an infinite loop. But infinite loops without side effects are also UB, so the compiler is well in its right to remove the loop entirely!
But even if the compiler does not perform these optimizations, the code still does not guarantee mutual exclusion, because the flag operations are not sequentially consistent. Essentially what can happen is that both threads store true in their respective flag, but it is not guaranteed that this updated value is visible to the other thread. So it can happen that the subsequent load operations in the while-loop still return false for both threads.
To get the desired behavior, the operations on the flags need to be sequentially consistent, which means that all such operations have a single total order. To achieve that you have to define your flags as std::atomic<bool>. All operations on atomics are sequentially consistent by default (unless specified otherwise).
However, since this is the third attempt by Dekker and not the final (correct) version, it does provide mutual exclusion (under a sequentially consistent memory model), but is prone to deadlocks!
For more details you should familiarize yourself with the C++ memory model. I can recommend the paper Memory Models for C/C++ Programmers which I have co-authored.

Answer 3

#include<iostream>
#include<conio.h>
#include<thread>
using namespace std;
bool turnop1 = false;
void p1()
{
for (int i = 1; i <= 10; i++)
{
while (turnop1 == false);
cout << "p1 : " << i << endl;
turnop1 = false;
}
}
void p2()
{
for (int t = -1; t >= -10; t--)
{
while (turnop1 == true);
cout << "p2 : " << t << endl;
turnop1 = true;
}
}
int main()
{
thread t1(p1);
thread t2(p2);
t2.join();
t1.join();
_getch();
return 0;
}
Modified your code and worked for me. Thanks! I know this is not completely right but this Dekker's idea/example is enough for a simple explanation.