Question

I have a linux multithread application in C++.
In this application in class App offer variable Status:

class App {
...
typedef enum { asStop=0, asStart, asRestart, asWork, asClose } TAppStatus;
TAppStatus Status; 
...
}

All threads are often check Status by calling GetStatus() function.

inline TAppStatus App::GetStatus(){ return Status };

Other functions of the application can assign a different values to a Status variable by calling SetStatus() function and do not use Mutexes.

void App::SetStatus( TAppStatus aStatus ){ Status=aStatus };

Edit: All threads use Status in switch operator:

switch ( App::GetStatus() ){ case asStop: ... case asStart: ... };

1. Is the assignment in this case, an atomic operation?
2. Is this correct code?

Thanks.

Answer 1

There is no portable way to implement synchronized variables in C99 or C++03 and pthread library does not provide one either. You can:

• Use C++0x <atomic> header (or C1x <stdatomic.h>). Gcc does support it for C++ if given -std=c++0x or -std=gnu++0x option since version 4.4.
• Use the Linux-specific <linux/atomic.h> (this is implementation used by kernel, but it should be usable from userland as well).
• Use GCC-specific __sync_* builtin functions.
• Use some other library that provides atomic operations like glib.
• Use locks, but that’s orders of magnitude slower compared to the fast operation itself.

Note: As Martinho pointed out, while they are called “atomic”, for store and load it’s not the atomic property (operation cannot be interrupted and load always sees or does not see the whole store, which is usually true of 32-bit stores and loads) but the ordering property (if you store a and than b, nobody may get new value of b and than old value of a) that is hard to get but necessary in this case.