突破编程_C++_C++11新特性（多线程编程的原子操作（2））
1 std::atomic 的加载与存储操作
加载和存储操作是 std::atomic
加载操作
加载操作是通过 load 成员函数实现的，它用于从原子变量中读取一个值。这个函数可以确保在读取过程中，不会被其他线程打断。
std::atomic<int> atomic_var(10); // 初始化一个原子变量，初始值为 10
int value = atomic_var.load(); // 原子加载操作，将 atomic_var 的值加载到 value 中
存储操作
存储操作是通过 store 成员函数实现的，它用于向原子变量中写入一个值。这个函数可以确保在写入过程中，不会被其他线程打断。
std::atomic<int> atomic_var(10); // 初始化一个原子变量，初始值为 10
atomic_var.store(20); // 原子存储操作，将 20 存储到 atomic_var 中
示例
以下是一个综合示例，展示如何使用这两个函数安全地在多个线程之间共享和更新一个原子整数。
#include 上面代码的输出为：
Final value of shared_data: 100
在这个示例中：
- shared_data 是一个原子整数，多个线程将对其进行增加和减少操作。
- increment 函数通过 load 加载当前值，增加它，然后使用 store 存储回原子变量中。
- decrement 函数使用了 compare_exchange_weak 函数，它执行一个比较和交换操作。这是一个更复杂的原子操作，它尝试将 shared_data 的当前值减少 1，但仅当该值仍然等于我们加载的值时。这有助于防止在减少过程中发生的数据竞争。
- 示例中创建了四个线程：两个用于增加 shared_data，两个用于减少它。
- 所有线程完成后，使用 load 函数获取 shared_data 的最终值，并打印出来。
注意，compare_exchange_weak 是一种更强大的原子操作，它通常用于实现更复杂的并发控制逻辑，如锁和无锁数据结构。在简单的增加和减少操作中，直接使用 load 和 store 也是可以的，但 compare_exchange_weak 可以提供更强大的保证，特别是在高并发环境下。
2 std::atomic 的交换操作
std::atomic
std::atomic
T exchange( T desired );
其中 desired 是需要与 std::atomic
- 保存 std::atomic
对象的当前值。 - 将 std::atomic
对象的值设置为 desired。 - 返回之前保存的 std::atomic
对象的值。
这个过程是原子的，即它在多线程环境中是线程安全的，不会有其他线程能够在这个操作执行期间改变 std::atomic
下面是一个使用 std::atomic
#include 上面代码的输出为：
Thread 10308 exchanged 10 with 0
Thread 11188 exchanged 130 with 200
Thread 9836 exchanged 240 with 300
Thread 7020 exchanged 20 with 100
Final value of counter: 300
在这个示例中：
- 创建了一个 std::atomic
类型的变量 counter，初始化为 0。 - 定义了一个 incrementAndExchange 函数，它接受两个参数：一个是要加到旧值上的增量，另一个是要与 counter 交换的新值。
- 在主函数中，创建了四个线程，每个线程都会调用 incrementAndExchange 函数，并传入不同的增量和新值。
- 每个线程都会原子地交换 counter 的值，并打印出交换前后的值。
- 最后，主线程通过 load 函数获取 counter 的最终值，并打印出来。
注意：由于多个线程同时尝试交换 counter 的值，因此最终值将取决于操作系统调度线程的顺序以及 exchange 操作的时机。因此，每次运行程序时，最终值都可能不同。
3 std::atomic 的比较并交换操作
std::atomic
std::atomic::compare_exchange_strong
compare_exchange_strong 函数执行一个“比较并交换”操作，如果当前值与预期值（期望的旧值）相等，则原子地将该值更新为新值。它提供了一种强一致性的内存模型保证，确保不会出现虚假失败的情况。
函数的原型如下：
bool compare_exchange_strong( T& expected, T desired );
expected 是一个引用，用于存储当前 std::atomic
desired 是想要设置的新值。
如果 std::atomi\c 对象的当前值与 expected 相等，则对象的值会被设置为 desired，并且 expected 会被更新为对象的新值（即 desired）。函数返回 true 表示交换成功。如果当前值与 expected 不相等，则对象的值不会被改变，expected 会被更新为对象的当前值，函数返回 false。
std::atomic::compare_exchange_weak
compare_exchange_weak 函数与 compare_exchange_strong 功能相似，也是执行一个“比较并交换”操作。但是，compare_exchange_weak 提供了一种弱一致性的内存模型保证，它可能在某些情况下返回失败，即使当前值与预期值相等（即所谓的“虚假失败”）。这种“弱”版本在某些场景下可能性能更好，但使用它需要更小心，因为需要准备重新尝试操作直到成功。
函数的原型如下：
bool compare_exchange_weak( T& expected, T desired );
其参数和返回值与 compare_exchange_strong 相同。
综合示例
下面是一个使用 std::atomic
#include 和compare_exchange_weak
class Spinlock {
public:
void lock() {
bool expected = false;
while (!locked_.compare_exchange_weak(expected, true)) {
// 如果锁被占用，则继续等待
expected = false; // 重置expected值，准备下一次比较交换
std::this_thread::yield(); // 可以让出CPU时间片
}
}
void unlock() {
locked_.store(false, std::memory_order_release);
}
private:
std::atomic<bool> locked_{ false };
};
// 临界区，需要保护的共享资源
int shared_resource = 0;
Spinlock spinlock;
void increment_shared_resource(int n) {
spinlock.lock();
for (int i = 0; i < n; ++i) {
++shared_resource;
}
spinlock.unlock();
}
int main()
{
const int numThreads = 4;
const int incrementAmount = 100000;
std::vector<std::thread> threads;
// 创建多个线程来增加共享资源
for (int i = 0; i < numThreads; ++i) {
threads.emplace_back(increment_shared_resource, incrementAmount);
}
// 等待所有线程完成
for (auto& thread : threads) {
thread.join();
}
// 输出共享资源的最终值
std::cout << "Final value of shared_resource: " << shared_resource << std::endl;
return 0;
}
上面代码的输出为：
Final value of shared_resource: 400000
在这个示例中：
- Spinlock 类现在包含一个 std::atomic 类型的 locked_ 成员变量，用于表示锁的状态。
- lock 方法使用 compare_exchange_weak 尝试将 locked_ 的值从 false 更改为 true。如果当前值不是 false（即锁已经被其他线程占用），则 compare_exchange_weak 返回 false，并且 expected 被设置为当前值（在这个例子中，始终是 true）。然后，线程会忙等待（自旋），再次尝试获取锁。
- unlock 方法简单地将 locked_ 的值设置回 false，释放锁。
这个示例展示了如何使用 std::atomic::compare_exchange_weak 来实现一个简单的自旋锁。与 std::atomic_flag 相比，std::atomic 提供了更多的灵活性和控制，但通常 std::atomic_flag 在实现自旋锁时会有更好的性能，因为它专为测试-和-设置操作而设计，且不涉及内存排序的额外开销。在大多数情况下，std::atomic_flag 是自旋锁的首选。然而，了解如何使用 std::atomic::compare_exchange_weak 或 std::atomic::compare_exchange_strong 也是很有价值的，因为它们可以用于实现更复杂的同步原语或算法。
4 std::atomic 的原子算术操作
std::atomic
- fetch_add(args): 将给定参数 args 加到当前值上，并返回操作前的值。
- fetch_sub(args): 从当前值中减去给定参数 args，并返回操作前的值。
- add_fetch(args): 将给定参数 args 加到当前值上，并返回操作后的值。
- sub_fetch(args): 从当前值中减去给定参数 args，并返回操作后的值。
下面是一个综合示例，演示了如何使用 std::atomic
#include 上面代码的输出为：
Final value of atomicInt: 40
在这个示例中：
- 定义了一个全局的 std::atomic
变量 atomicInt，并初始化为 0。 - incrementAtomicInt 函数被多个线程调用，每个线程使用 fetch_add 方法原子地增加 atomicInt 的值，并输出操作前后的值。
- 在 main 函数中，创建了多个线程，每个线程执行 incrementAtomicInt 函数。
- 所有线程执行完毕后，输出 atomicInt 的最终值。由于使用了原子操作，即使多个线程同时修改 atomicInt，最终的结果也是正确的，即 numThreads * incrementAmount。
5 std::atomic 的原子位操作
除了原子算术操作外，std::atomic
std::atomic
- fetch_and(T desired): 对当前值执行原子位与操作，并返回操作前的值。
- fetch_or(T desired): 对当前值执行原子位或操作，并返回操作前的值。
- fetch_xor(T desired): 对当前值执行原子位异或操作，并返回操作前的值。
- and_fetch(T desired): 对当前值执行原子位与操作，并返回操作后的值。
- or_fetch(T desired): 对当前值执行原子位或操作，并返回操作后的值。
- xor_fetch(T desired): 对当前值执行原子位异或操作，并返回操作后的值。
下面是一个综合示例，展示了如何使用 std::atomic
#include 上面代码的输出为：
Final value of atomicInt: 11111111111111111111111111111010
在这个示例中：
- 定义了一个全局的 std::atomic
变量 atomicInt，并初始化为二进制值 1010。 - modifyAtomicInt 函数被多个线程调用，每个线程使用 fetch_and 和 fetch_or 方法原子地修改 atomicInt 的值，并输出操作前后的值。这里使用了 std::bitset 来以二进制形式输出整数值。
- 在 main 函数中，创建了多个线程，每个线程执行 modifyAtomicInt 函数，并传入一个二进制掩码 mask。
- 所有线程执行完毕后，输出 atomicInt 的最终值