std::atomic_fetch_add, std::atomic_fetch_add_explicit

<metanoindex/>

 

C++

Linguaggio

Concetti

Libreria di Utilità

Stringhe

Contenitori

Algoritmi

Iteratori

Libreria matematca

Input/output

Localizzazione

Espressioni regolari (C++11)

Operazioni atomicche (C++11)

Multithreading (C++11)

 

Atomic operazioni di biblioteca

Tipi 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)

Funzioni 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)

Bandiere Atomic 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)

Inizializzazione 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)

Memoria di ordinazione 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)

 

<tbody> </tbody>

Elemento definito nell'header <atomic>
template< class Integral > Integral atomic_fetch_add( std::atomic<Integral>* obj, Integral arg );	(1)	(dal C++11)
template< class Integral > Integral atomic_fetch_add( volatile std::atomic<Integral>* obj, Integral arg );	(2)	(dal C++11)
template< class Integral > Integral atomic_fetch_add_explicit( std::atomic<Integral>* obj, Integral arg, std::memory_order order );	(3)	(dal C++11)
template< class Integral > Integral atomic_fetch_add_explicit( volatile std::atomic<Integral>* obj, Integral arg, std::memory_order order );	(4)	(dal C++11)
template< class T > T* atomic_fetch_add( std::atomic<T*>* obj, std::ptrdiff_t arg );	(5)	(dal C++11)
template< class T > T* atomic_fetch_add( volatile std::atomic<T*>* obj, std::ptrdiff_t arg );	(6)	(dal C++11)
template< class T > T* atomic_fetch_add_explicit( std::atomic<T*>* obj, std::ptrdiff_t arg, std::memory_order order );	(7)	(dal C++11)
template< class T > T* atomic_fetch_add_explicit( volatile std::atomic<T*>* obj, std::ptrdiff_t arg, std::memory_order order );	(8)	(dal 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)

Parametri

obj	-	puntatore all'oggetto atomica da modificare 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	-	il valore da aggiungere al valore memorizzato nell'oggetto atomica Original: the value to add to 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 memoria di ordinazione per questa operazione: tutti i valori sono consentiti . 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.

Valore di ritorno

Il valore contenuto in precedenza dall'oggetto atomico puntato da 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.

Eccezioni

noexcept specification:  

<tbody> </tbody>

noexcept

  (dal C++11)

Possibile implementazione

First version
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); }
Second version
template< class T > T* atomic_fetch_add( std::atomic<T*>* obj, std::ptrdiff_t arg) { return obj->fetch_add(arg); }

Esempio

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();
    }
}

Output:

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

Vedi anche

fetch_add (C++11)	aggiunge atomicamente l'argomento al valore memorizzato nell'oggetto atomica e ottiene il valore contenuto in precedenza Original: atomically adds the argument to 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. (metodo pubblico)
atomic_fetch_sub atomic_fetch_sub_explicit (C++11) (C++11)	sottrae un valore non-atomico da un oggetto atomico e ottiene il valore precedente della atomico Original: subtracts a non-atomic value from 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. (funzione di modello)
C documentation for atomic_fetch_add, atomic_fetch_add_explicit