原子读取，然后用std :: atomic写入

Question

Assume the following code

#include <iostream>
#include <atomic>
#include <chrono>
#include <thread>

std::atomic<uint> val;

void F()
{
   while(true)
   {
      ++val;
   }
}

void G()
{
   while(true)
   {
      ++val;
   }
}

void H()
{
   while(true)
   {
      std::this_thread::sleep_for(std::chrono::seconds(1));
      std::cout <<"val="<< val << std::endl;
      val = 0;
   }
}

int main()
{
   std::thread ft(F);
   std::thread gt(G);
   std::thread ht(H);
   ft.join();
   gt.join();
   ht.join();

   return 0;
}

It is basically two threads incrementing the value of val and a third thread which reports this value every second then resets it. The problem is, when the third thread is reading this value and then sets it to zero, there can be possible increments which will be lost (we did not include them in report). So we need an atomic read-then-write mechanism. Is there a clean way to do this that I am not aware of? PS: I don't want to lock anything

Answer 1

The std::atomic::exchange method seems to be what you're after (emphasis mine):

Atomically replaces the underlying value with desired. The operation is read-modify-write operation.

---

Use as follows:

auto localValue = val.exchange(0);
std::cout << "Value = " << localValue << std::endl;

Answer 2

As others mentioned std::atomic::exchange would work.

To mention why your current code does what you said, between the two lines of execution:

 std::cout <<"val="<< val << std::endl; val = 0; 

the other two threads have time to increment the value that ht thread is about to reset.

std::atomic::exchange would do those lines in one "atomic" operation.