当前位置：首页 > article >正文

原子操作 std::atomic

article 2024/11/14 2:22:20

std::atomic 是 C++11 引入的一个模板类，用于实现原子操作。原子操作是不可分割的操作，它们在多线程环境下可以安全地执行，而无需额外的同步机制（如互斥锁）。std::atomic 提供了对基本数据类型的原子操作支持，如整数、布尔值、指针等。

以下是 std::atomic 的一些基本用法示例：

1. 引入头文件

首先，你需要包含 <atomic> 头文件：

#include <atomic>

2. 声明和使用 `std::atomic` 变量

你可以声明一个 std::atomic 类型的变量，例如一个原子整数：

std::atomic<int> atomicInt(0);

3. 原子操作

std::atomic 提供了一些成员函数来进行原子操作，例如 store、load、exchange、fetch_add、fetch_sub、compare_exchange_weak、compare_exchange_strong 等。

读取和写入原子变量

int value = atomicInt.load(); // 原子读取
atomicInt.store(42);          // 原子写入

原子加减操作

int oldValue = atomicInt.fetch_add(1); // 原子地将 atomicInt 的值加 1，并返回旧值
int newValue = atomicInt.fetch_sub(1); // 原子地将 atomicInt 的值减 1，并返回旧值

原子比较和交换

int expected = 42;
if (atomicInt.compare_exchange_strong(expected, 100)) {
    // 如果 atomicInt 的值等于 expected（42），则将其设置为 100，并返回 true
} else {
    // 如果 atomicInt 的值不等于 expected（42），则 expected 被设置为 atomicInt 的当前值，并返回 false
}

4. 原子自增和自减

虽然 fetch_add 和 fetch_sub 可以实现自增和自减，但 std::atomic 还提供了更简洁的操作符重载：

++atomicInt; // 原子自增
--atomicInt; // 原子自减

5. 原子布尔操作

对于布尔值，std::atomic 也提供了支持：

std::atomic<bool> atomicBool(false);

if (!atomicBool.load()) {
    atomicBool.store(true);
}

// 或者使用更简洁的操作符重载
atomicBool = true;
bool value = atomicBool.load();

6. 使用 `std::atomic_flag`

std::atomic_flag 是一个简单的原子布尔类型，它只支持两种操作：set 和 clear，以及 test_and_set。

std::atomic_flag flag = ATOMIC_FLAG_INIT;

// 设置标志位
flag.set();

// 清除标志位
flag.clear();

// 原子地测试并设置标志位，如果标志位之前为 false，则返回 false 并将其设置为 true；否则返回 true
bool wasSet = flag.test_and_set();

示例代码

以下是一个完整的示例代码，展示了 std::atomic 的基本用法：

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>

std::atomic<int> counter(0);

void incrementCounter(int id, int iterations) {
    for (int i = 0; i < iterations; ++i) {
        ++counter;
    }
    std::cout << "Thread " << id << " incremented counter " << iterations << " times.\n";
}

int main() {
    const int numThreads = 10;
    const int iterationsPerThread = 1000;
    std::vector<std::thread> threads;

    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(incrementCounter, i, iterationsPerThread);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Final counter value: " << counter.load() << "\n";

    return 0;
}