std::atomic_fetch_add, std::atomic_fetch_add_explicit
Материал из cppreference.com
 |
Эта страница была переведена автоматически с английской версии вики используя Переводчик Google. Перевод может содержать ошибки и странные формулировки. Наведите курсор на текст, чтобы увидеть оригинал. Щёлкните здесь, чтобы увидеть английскую версию этой страницы. (Вы можете помочь в исправлении ошибок и улучшении перевода. Для инструкций перейдите по ссылке.) |
<metanoindex/>
<tbody> </tbody>| Определено в заголовочном файле <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. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. |
| arg | — | значение, добавляемое к значению, хранящемуся в атомном объекте
Оригинал: the value to add to the value stored in the atomic object Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. |
| order | — | памяти sycnhronization заказа для этой операции: все допустимые значения .
Оригинал: the memory sycnhronization ordering for this operation: all values are permitted. Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. |
Возвращаемое значение
Значение состоялась ранее атомный объект, на который указывает
objОригинал:
The value held previously by the atomic object pointed to by
objТекст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Исключения
спецификация noexcept:
noexceptВозможная реализация
| Первый вариант |
|---|
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
См. также
| атомарно добавляет аргумент к значению, хранящемуся в атомарном объекте, и получает значение, сохранённое ранее (public функция-элемент std::atomic)
| |
(C++11)(C++11) |
вычитает неатомарное значение из атомарного объекта и получает предыдущее атомарное значение (шаблон функции) |
Документация C по atomic_fetch_add, atomic_fetch_add_explicit
| |
