std::atomic_fetch_sub, std::atomic_fetch_sub_explicit
De 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. |
<metanoindex/>
<tbody> </tbody>| Déclaré dans l'en-tête <atomic>
|
||
template< class Integral > Integral atomic_fetch_sub( std::atomic<Integral>* obj, Integral arg ); |
(1) | (depuis C++11) |
template< class Integral > Integral atomic_fetch_sub( volatile std::atomic<Integral>* obj, Integral arg ); |
(2) | (depuis C++11) |
template< class Integral > Integral atomic_fetch_sub_explicit( std::atomic<Integral>* obj, Integral arg, std::memory_order order ); |
(3) | (depuis C++11) |
template< class Integral > Integral atomic_fetch_sub_explicit( volatile std::atomic<Integral>* obj, Integral arg, std::memory_order order); |
(4) | (depuis C++11) |
template< class T > T* atomic_fetch_sub( std::atomic<T*>* obj, std::ptrdiff_t arg ); |
(5) | (depuis C++11) |
template< class T > T* atomic_fetch_sub( volatile std::atomic<T*>* obj, std::ptrdiff_t arg ); |
(6) | (depuis C++11) |
template< class T > T* atomic_fetch_sub_explicit( std::atomic<T*>* obj, std::ptrdiff_t arg, std::memory_order order ); |
(7) | (depuis C++11) |
template< class T > T* atomic_fetch_sub_explicit( volatile std::atomic<T*>* obj, std::ptrdiff_t arg, std::memory_order order ); |
(8) | (depuis 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)
Paramètres
| obj | - | pointeur vers l'objet à modifier atomique
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 | - | la valeur à soustraire de la valeur stockée dans l'objet atomique
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 la mémoire de commande pour cette opération: toutes les valeurs sont autorisées .
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. |
Retourne la valeur
La valeur détenue précédemment par l'objet atomique pointée par
objOriginal:
The value held previously by the atomic object pointed to by
objThe text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
Exceptions
Mise en œuvre possible
| 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);
}
|
Exemple
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();
}
}
Résultat :
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
Voir aussi
(C++11) |
soustrait atomiquement l'argument de la valeur stockée dans l'objet atomique et obtient la valeur détenue précédemment 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. (fonction membre publique de std::atomic)
|
(C++11) (C++11) |
ajoute une valeur non atomique à un objet atomique et obtient la valeur précédente de l'atome 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. (fonction générique) |
C documentation for atomic_fetch_sub, atomic_fetch_sub_explicit
| |