According to this article:
Any time two threads operate on a shared variable concurrently, and one of those operations performs a write, both threads must use atomic operations.
However, if a lower-priority thread is the writer, and a higher-priority thread is the reader, does the lower-priority thread need to enforce atomic stores? It seems to me that only the higher-priority thread needs to enforce an atomic load:
#include <atomic>std::atomic<T*> ptr; // assume initialized to some non-null valuevoid highPriThreadFcn(void){ T* local_ptr = ptr.load(); // need atomic load here in case lowPriThread write/store was interrupted}void lowPriThreadFcn(T* some_ptr){ ptr = some_ptr; // do I need an atomic store here? I'd think not, as ptr is not written to by highPriThread}A similar question would apply in the "reverse" case (write in high-priority thread, read from low-priority thread):
void highPriThreadFcn(T* some_ptr){ ptr = some_ptr; // do I need an atomic store here? I'd think not, as write to ptr cannot be interrupted}void lowPriThreadFcn(void){ T* local_ptr = ptr.load(); // need atomic load here in case read/load was interrupted}