public member function
<atomic>

std::atomic::exchange

T exchange (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;T exchange (T val, memory_order sync = memory_order_seq_cst) noexcept;
访问并修改包含的值
val 替换为包含的值,并返回它之前的值。

整个操作是原子的(一个原子读-修改-写操作):在函数读取(并返回)其值到修改其值的时刻之间,该值不会受到其他线程的影响。

参数

val
要复制到包含对象的值。
Tatomic 的模板参数(包含值的类型)。
sync
操作的同步模式。
可以是 enum 类型 memory_order 的任何可能值
memory order描述
memory_order_relaxedRelaxed无副作用同步。
memory_order_consumeConsume同步来自最后一个releasesequentially consistent 操作的带有依赖关系的值的可见副作用。
memory_order_acquireAcquire同步来自最后一个releasesequentially consistent 操作的所有可见副作用。
memory_order_releaseRelease将副作用与下一个consumeacquire 操作同步。
memory_order_acq_relAcquire/Release读取为acquire 操作,写入为release 操作(如上所述)。
memory_order_seq_cstSequentially consistent将所有可见的副作用与其他的sequentially consistent 操作同步,遵循单一的全局顺序。

返回值

调用前的存储值。
Tatomic 的模板参数(包含值的类型)。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// atomic::exchange example
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector

std::atomic<bool> ready (false);
std::atomic<bool> winner (false);

void count1m (int id) {
  while (!ready) {}                  // wait for the ready signal
  for (int i=0; i<1000000; ++i) {}   // go!, count to 1 million
  if (!winner.exchange(true)) { std::cout << "thread #" << id << " won!\n"; }
};

int main ()
{
  std::vector<std::thread> threads;
  std::cout << "spawning 10 threads that count to 1 million...\n";
  for (int i=1; i<=10; ++i) threads.push_back(std::thread(count1m,i));
  ready = true;
  for (auto& th : threads) th.join();

  return 0;
}

可能的输出(其他线程可能获胜)
spawning 10 threads that count to 1 million...
thread #7 won!


数据竞争

无数据竞争(原子操作)。内存顺序由参数 sync 指定。

异常安全

无异常保证: 绝不抛出异常。

另见