std::atomic_fetch_add, std::atomic_fetch_add_explicit

定义于头文件 `<atomic>`
template< class T > T atomic_fetch_add( std::atomic<T>* obj, typename std::atomic<T>::difference_type arg ) noexcept;	(1)	(自 C++11 起)
template< class T > T atomic_fetch_add( volatile std::atomic<T>* obj, typename std::atomic<T>::difference_type arg ) noexcept;	(2)	(自 C++11 起)
template< class T > T atomic_fetch_add_explicit( std::atomic<T>* obj, typename std::atomic<T>::difference_type arg, std::memory_order order ) noexcept;	(3)	(自 C++11 起)
template< class T > T atomic_fetch_add_explicit( volatile std::atomic<T>* obj, typename std::atomic<T>::difference_type arg, std::memory_order order ) noexcept;	(4)	(自 C++11 起)

执行原子加法。原子地将 arg 加到 obj 指向的值，并返回 obj 先前持有的值。此操作的执行方式如同执行了以下代码

1,2) obj->fetch_add(arg)

3,4) obj->fetch_add(arg, order)

如果 std::atomic<T> 没有 fetch_add 成员（此成员仅为 integral、 floating-point(自 C++20 起) 和 pointer 类型提供，除了 bool），则程序是非良构的。

[编辑] 参数

obj	-	指向要修改的原子对象的指针
arg	-	要添加到原子对象中存储的值的值
order	-	内存同步顺序

[编辑] 返回值

在 *obj 的修改顺序中，紧接在此函数效果之前的值。

[编辑] 示例

可以使用 std::atomic_fetch_add 创建单写/多读锁。请注意，这种简单的实现并非无死锁的。

运行此代码

#include <atomic>
#include <chrono>
#include <iostream>
#include <string>
#include <thread>
#include <vector>
 
using namespace std::chrono_literals;
 
// meaning of cnt:
//  5: readers and writer are in race. There are no active readers or writers.
//  4...0: there are 1...5 active readers, The writer is blocked.
// -1: writer won the race and readers are blocked.
 
const int N = 5; // four concurrent readers are allowed
std::atomic<int> cnt(N);
 
std::vector<int> data;
 
void reader(int id)
{
    for (;;)
    {
        // lock
        while (std::atomic_fetch_sub(&cnt, 1) <= 0)
            std::atomic_fetch_add(&cnt, 1);
 
        // read
        if (!data.empty())
            std::cout << ("reader " + std::to_string(id) +
                          " sees " + std::to_string(*data.rbegin()) + '\n');
        if (data.size() == 25)
            break;
 
        // unlock
        std::atomic_fetch_add(&cnt, 1);
 
        // pause
        std::this_thread::sleep_for(1ms);
    }
}
 
void writer()
{
    for (int n = 0; n < 25; ++n)
    {
        // lock
        while (std::atomic_fetch_sub(&cnt, N + 1) != N)
            std::atomic_fetch_add(&cnt, N + 1);
 
        // write
        data.push_back(n);
        std::cout << "writer pushed back " << n << '\n';
 
        // unlock
        std::atomic_fetch_add(&cnt, N + 1);
 
        // pause
        std::this_thread::sleep_for(1ms);
    }
}
 
int main()
{
    std::vector<std::thread> v;
    for (int n = 0; n < N; ++n)
        v.emplace_back(reader, n);
    v.emplace_back(writer);
 
    for (auto& t : v)
        t.join();
}

输出

writer pushed back 0
reader 2 sees 0
reader 3 sees 0
reader 1 sees 0
<...>
reader 2 sees 24
reader 4 sees 24
reader 1 sees 24

[编辑] 缺陷报告

以下行为变更缺陷报告已追溯应用于先前发布的 C++ 标准。

DR	应用于	已发布行为	正确行为
P0558R1	C++11	需要精确的类型匹配，因为 `T` 是从多个参数推导出来的	`T` 仅被推导来自 obj

[编辑] 参见

fetch_add	原子地将参数添加到原子对象中存储的值，并获取先前持有的值 (std::atomic<T> 的公共成员函数) [编辑]
atomic_fetch_subatomic_fetch_sub_explicit (C++11)(C++11)	从原子对象中减去一个非原子值，并获取原子的先前值 (函数模板) [编辑]
`C` 文档，关于 atomic_fetch_add, atomic_fetch_add_explicit

编译器支持
独立式和宿主式
语言
标准库
标准库头文件
具名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

cppreference.cn

命名空间

变体

视图

操作