Ist nacheinander eine konsistente Speicherbestellung in diesem C ++ -Anspiel ausschließlich notwendig? ⇐ C++

[Anonymous]

Betrachten Sie diesen Umriss einer einfachen Multi-Thread-Anwendung. Es hat einen Writer -Thread und zehn Leser -Threads. < /P>
#include
#include

const int Num_readers{10};

std::atomic write_lock;

std::atomic read_lock[Num_readers];

void reader_thread(int reader_number)
{
auto &rl{read_lock[reader_number]};

for (;;)
{
for (;;)
{
rl.store(true, std::memory_order_seq_cst);

if (not write_lock.load(std::memory_order_seq_cst))
break;

// Avoid writer starvation.
rl.store(false, std::memory_order_seq_cst);

while (write_lock.load(std::memory_order_relaxed))
std::this_thread::yield();
}

// Read stuff from writer.
}
}

void writer_thread()
{
for (;;)
{
write_lock.store(true, std::memory_order_seq_cst);

bool have_lock;
do
{
have_lock = true;
for (const auto &rl : read_lock)
if (rl.load(std::memory_order_seq_cst))
{
have_lock = false;
std::this_thread::yield();
break;
}
}
while (not have_lock);

// Write stuff for readers.

write_lock.store(false, std::memory_order_seq_cst);

std::this_thread::yield();
}
}
< /code>
(Angenommen, die Threads sind statisch.) Der Zweck der Atomvariablen ist der gegenseitige Ausschluss von Schreiben und Lesen. Könnte die Speicherreihenfolge für eine der Atomlasten oder -speicher weniger streng gemacht werden?