The Wayback Machine - https://web.archive.org/web/20130310154603/http://zh.cppreference.com/w/cpp/atomic/atomic_fetch_sub

std::atomic_fetch_sub, std::atomic_fetch_sub_explicit

来自cppreference.com

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

 
C++
 
原子操作库
类型
Original:
Types
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
atomic（C++11）
atomic_is_lock_free（C++11）
功能
Original:
Functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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）
原子标志
Original:
Atomic flags
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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）
初始化
Original:
Initialization
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
atomic_init（C++11）
ATOMIC_VAR_INIT（C++11）
ATOMIC_FLAG_INIT（C++11）
内存排序
Original:
Memory ordering
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
memory_order（C++11）
kill_dependency（C++11）
atomic_thread_fence（C++11）
atomic_signal_fence（C++11）
 
Defined in header <atomic>
template< class Integral >
Integral atomic_fetch_sub( std::atomic<Integral>* obj, Integral arg );
 (1) （C++11 起）
template< class Integral >
Integral atomic_fetch_sub( volatile std::atomic<Integral>* obj, Integral arg );
 (2) （C++11 起）
template< class Integral >

Integral atomic_fetch_sub_explicit( std::atomic<Integral>* obj, Integral arg,

                                    std::memory_order order );
 (3) （C++11 起）
template< class Integral >

Integral atomic_fetch_sub_explicit( volatile std::atomic<Integral>* obj, Integral arg,

                                    std::memory_order order);
 (4) （C++11 起）
template< class T >
T* atomic_fetch_sub( std::atomic<T*>* obj, std::ptrdiff_t arg );
 (5) （C++11 起）
template< class T >
T* atomic_fetch_sub( volatile std::atomic<T*>* obj, std::ptrdiff_t arg );
 (6) （C++11 起）
template< class T >

T* atomic_fetch_sub_explicit( std::atomic<T*>* obj, std::ptrdiff_t arg,

                              std::memory_order order );
 (7) （C++11 起）
template< class T >

T* atomic_fetch_sub_explicit( volatile std::atomic<T*>* obj, std::ptrdiff_t arg,

                              std::memory_order order );
 (8) （C++11 起）

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

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

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

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

目录

[编辑] 参数

obj -
指针的原子对象修改
Original:
pointer to the atomic object to modify
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
arg -
从原子对象中存储的值中减去该值
Original:
the value to subtract from the value stored in the atomic object
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
order -
的的内存sycnhronization订购此操作：所有的允许值.
Original:
the memory sycnhronization ordering for this operation: all values are permitted.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[编辑] 返回值

以前保存的值的原子对象所指向的obj
Original:
The value held previously by the atomic object pointed to by obj
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[编辑] 例外

noexcept specification:  
noexcept
  （C++11 起）

[编辑] 可能的实现

First version 
template< class T >
typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value, T>::type
atomic_fetch_sub( std::atomic<T>* obj, T arg );
{
    return obj->fetch_sub(arg);
}
Second version 
template< class T >
T* atomic_fetch_sub( std::atomic<T*>* obj, std::ptrdiff_t arg)
{
    return obj->fetch_sub(arg);
}

[编辑] 为例

Multiple threads may use fetch_sub to concurrently process an indexed container 

#include <string>
#include <thread>
#include <vector>
#include <iostream>
#include <atomic>
#include <numeric>
 
const int N = 10000;
std::atomic<int> cnt;
std::vector<int> data(N);
 
void reader(int id) 
{
    for(;;) {
        int idx = atomic_fetch_sub_explicit(&cnt, 1, std::memory_order_relaxed);
        if (idx >= 0) {
            std::cout << "reader " << std::to_string(id) << " processed item "
                      << std::to_string(data[idx]) << '\n';
        } else {
            std::cout << "reader " << std::to_string(id) << " done\n";
            break;
        }
    }
}
 
int main()
{
    std::iota(data.begin(), data.end(), 1);
    cnt = data.size() - 1;
 
    std::vector<std::thread> v;
    for (int n = 0; n < 10; ++n) {
        v.emplace_back(reader, n);
    }
    for (auto& t : v) {
        t.join();
    }
}

Output: 

reader 2 processed item 10000
reader 6 processed item 9994
reader 4 processed item 9996
reader 6 processed item 9992
<....>
reader 0 done
reader 5 done
reader 3 done
reader 9 done

[编辑] 另请参阅

（C++11）
原子地减的说法，从原子对象中存储的值，并获得先前保存的值
Original:
atomically subtracts the argument from the value stored in the atomic object and obtains the value held previously
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

（公共成员函数of std::atomic） [edit]
（C++11）
（C++11）
添加的非原子一个原子对象的价值，并获得以前的值的原子
Original:
adds a non-atomic value to an atomic object and obtains the previous value of the atomic
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

（函数模板） [edit]
C documentation for atomic_fetch_sub, atomic_fetch_sub_explicit
来自“http://zh.cppreference.com/mwiki/index.php?title=cpp/atomic/atomic_fetch_sub&oldid=27464”