How to avoid using volatile for lockfree program? - c++

Question

My program is comprised of a bunch of threads happily chugging along, and the only synchronization I have is a volatile global bool that tells them if the user exited. All other communication between the threads is lockfree. These threads constantly have work to do, in a very time critical application, so I can't afford having locks between them. I recently came across a lot of information showing that volatile is bad for multi-threading, so I want to make my code better. I saw that std::atomic_flag is guaranteed lockfree, but I can't figure out how to use it for my case.
The basic setup is like this (omitting different files that the code is in):
// Global variable in its own .h file
extern volatile bool SystemOnline;
// Initialization in a .cpp file
volatile bool SystemOnline = true;
// Windows message processing
while (SystemOnline)
{
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
{
SystemOnline = false;
}
else if (!TranslateAccelerator(msg.hwnd, NULL, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
// Thread functions
void Thread1()
{
while (SystemOnline)
{
// Do some work
}
}
void Thread2()
{
while (SystemOnline)
{
// Do some other work
}
}
// And so on...
All threads are joined at the end.

Answer 1

First, let's fix the bigger performance problem first. Your main Win32 thread is spinning without waiting. That's going to negate any perceived performance difference between a lockless bool and an std::atomic.
You'll burn an entire core just invoking PeekMessage redundantly on an empty queue. So instead of this:
while (SystemOnline)
{
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
{
SystemOnline = false;
}
else if (!TranslateAccelerator(msg.hwnd, NULL, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
Let's do the following which is exactly equivalent to what you have above except that GetMessage will block until an incoming message arrives. And GetMessage returns FALSE when a WM_QUIT message is dequeued.
MSG msg;
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(msg.hwnd, NULL, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
SystemOnline = false;
And as other have pointed out, the conversion from a global bool to an atomic is pretty simple:
Just change this global:
// Global variable in its own .h file
extern volatile bool SystemOnline;
// Initialization in a .cpp file
volatile bool SystemOnline = true;
To this:
// Global variable in its own .h file
#include <atomic>
extern std::atomic<bool> SystemOnline;
// Initialization in a .cpp file
std::atomic<bool> SystemOnline(true);
You can also use std::atomic_bool - it's a typedef for std::atomic<bool>
And that's all you have to do. You don't even have to change your thread code since the () operator for this type just invokes the load() method on the object. Similarly, the = false assignment at the end of the main thread loop is the same as invoking SystemOnline.store(false).
As others have pointed out, there really isn't much of a performance penalty for using the atomic. On x86, it maps to the LOCK opcode prefix.