std::atomic_fetch_add, std::atomic_fetch_add_explicit

 

C++

语言

概念

实用工具库

字符串库

集装箱库

算法库

迭代器库

Numerics库

输入/输出库

本地化库

正则表达式库 （C++11）

原子操作库 （C++11）

线程的支持库 （C++11）

 

原子操作库

类型 原文： Types 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

atomic （C++11）

atomic_is_lock_free （C++11）

功能 原文： Functions 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

atomic_store atomic_store_explicit （C++11） （C++11）

atomic_load atomic_load_explicit （C++11） （C++11）

atomic_exchange atomic_exchange_explicit （C++11） （C++11）

atomic_compare_exchange_weak atomic_compare_exchange_weak_explicit atomic_compare_exchange_strong atomic_compare_exchange_strong_explicit （C++11） （C++11） （C++11） （C++11）

atomic_fetch_add atomic_fetch_add_explicit （C++11） （C++11）

atomic_fetch_sub atomic_fetch_sub_explicit （C++11） （C++11）

atomic_fetch_and atomic_fetch_and_explicit （C++11） （C++11）

atomic_fetch_or atomic_fetch_or_explicit （C++11） （C++11）

atomic_fetch_xor atomic_fetch_xor_explicit （C++11） （C++11）

原子标志 原文： Atomic flags 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

atomic_flag （C++11）

atomic_flag_test_and_set atomic_flag_test_and_set_explicit （C++11） （C++11）

atomic_flag_clear atomic_flag_clear_explicit （C++11） （C++11）

初始化 原文： Initialization 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

atomic_init （C++11）

ATOMIC_VAR_INIT （C++11）

ATOMIC_FLAG_INIT （C++11）

内存排序 原文： Memory ordering 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

memory_order （C++11）

kill_dependency （C++11）

atomic_thread_fence （C++11）

atomic_signal_fence （C++11）

 

在头文件 <atomic> 中定义
template< class Integral > Integral atomic_fetch_add( std::atomic<Integral>* obj, Integral arg );	(1)	（C++11 起）
template< class Integral > Integral atomic_fetch_add( volatile std::atomic<Integral>* obj, Integral arg );	(2)	（C++11 起）
template< class Integral > Integral atomic_fetch_add_explicit( std::atomic<Integral>* obj, Integral arg,                                     std::memory_order order );	(3)	（C++11 起）
template< class Integral > Integral atomic_fetch_add_explicit( volatile std::atomic<Integral>* obj, Integral arg,                                     std::memory_order order );	(4)	（C++11 起）
template< class T > T* atomic_fetch_add( std::atomic<T*>* obj, std::ptrdiff_t arg );	(5)	（C++11 起）
template< class T > T* atomic_fetch_add( volatile std::atomic<T*>* obj, std::ptrdiff_t arg );	(6)	（C++11 起）
template< class T > T* atomic_fetch_add_explicit( std::atomic<T*>* obj, std::ptrdiff_t arg,                               std::memory_order order );	(7)	（C++11 起）
template< class T > T* atomic_fetch_add_explicit( volatile std::atomic<T*>* obj, std::ptrdiff_t arg,                               std::memory_order order );	(8)	（C++11 起）

1-2) Atomically adds arg to the value pointed to by obj and returns the value obj held previously, as if by obj->fetch_add(arg)

3-4) Atomically adds arg to the value pointed to by obj and returns the value obj held previously, as if by obj->fetch_add(arg, order)

5-6) Atomically increments the pointer value, pointed to by obj, by arg, and returns the value obj held previously, as if by obj->fetch_add(arg)

7-8) Atomically increments the pointer value, pointed to by obj, by arg, and returns the value obj held previously, as if by obj->fetch_add(arg, order)

参数

obj	-	指针的原子对象修改 原文： pointer to the atomic object to modify 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
arg	-	的值添加到原子对象中存储的值 原文： the value to add to the value stored in the atomic object 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
order	-	的的内存sycnhronization订购此操作：所有的允许值. 原文： the memory sycnhronization ordering for this operation: all values are permitted. 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

返回值

以前保存的值的原子对象所指向的obj

原文：

The value held previously by the atomic object pointed to by obj

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

例外

noexcept specification:  

noexcept

  （C++11 起）

可能的实现

版本一
template< class T > typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value, T>::type atomic_fetch_add( std::atomic<T>* obj, T arg ); { return obj->fetch_add(arg); }
版本二
template< class T > T* atomic_fetch_add( std::atomic<T*>* obj, std::ptrdiff_t arg) { return obj->fetch_add(arg); }

示例

Single-writer/multiple-reader lock can be made with fetch_add. Note that this simplistic implementation is not lockout-free

#include <string>
#include <thread>
#include <vector>
#include <iostream>
#include <atomic>
#include <chrono>
 
// meaning of cnt:
// 10: there are no active readers or writers.
// 1...9: there are 9...1 readers active, The writer is blocked
// 0: temporary value between fetch_sub and fetch_add in reader lock
// -1: there is a writer active. The readers are blocked.
const int N = 10; // nine concurrent readers are allowed
std::atomic<int> cnt = ATOMIC_VAR_INIT(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() == 100)
            break;
        // unlock
        std::atomic_fetch_add(&cnt, 1);
        // pause
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
}
 
void writer()
{
    for(int n = 0; n < 100; ++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(std::chrono::milliseconds(1));
    }
}
 
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 8 sees 0
reader 3 sees 0
reader 1 sees 0
<...>
reader 2 sees 99
reader 6 sees 99
reader 1 sees 99

另请参阅

fetch_add （C++11）	原子级的参数的值存储在原子对象，并获得先前保存的值 原文： atomically adds the argument to the value stored in the atomic object and obtains the value held previously 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。 （公共成员函数of std::atomic）
atomic_fetch_sub atomic_fetch_sub_explicit （C++11） （C++11）	减去从一个原子对象的非原子值和获得原子的先前的值 原文： subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。 （函数模板）
C documentation for atomic_fetch_add, atomic_fetch_add_explicit