Bibliothèque atomique C ++ - Extraire Ajouter

La description

Il ajoute une valeur non atomique à un objet atomique et obtient la valeur précédente de l'atome.

Déclaration

Voici la déclaration pour std :: atomic_fetch_add.

template< class Integral >
Integral atomic_fetch_add( std::atomic<Integral>* obj, Integral arg );

C ++ 11

template< class Integral >
Integral atomic_fetch_add( volatile std::atomic<Integral>* obj, Integral arg );

Voici la déclaration pour std :: atomic_fetch_add_explicit.

template< class T >
T* atomic_fetch_add_explicit( volatile std::atomic<T*>* obj, std::ptrdiff_t arg, 
                              std::memory_order order );

C ++ 11

template< class T >
T* atomic_fetch_add_explicit( std::atomic<T*>* obj, std::ptrdiff_t arg, 
                              std::memory_order order );

Paramètres

• obj - Il est utilisé en pointeur sur l'objet atomique à modifier.

• desr - Il est utilisé pour stocker la valeur dans l'objet atomique.

• order - Il est utilisé pour synchroniser l'ordre de mémoire pour cette opération.

Valeur de retour

Il renvoie la valeur précédant immédiatement les effets de cette fonction dans l'ordre de modification de * obj.

Exceptions

No-noexcept - cette fonction membre ne lève jamais d'exceptions.

Exemple

Dans l'exemple ci-dessous pour std :: atomic_fetch_add_explicit.

#include <string>
#include <thread>
#include <vector>
#include <iostream>
#include <atomic>
#include <chrono>
 
const int N = 10; 
std::atomic<int> cnt = ATOMIC_VAR_INIT(N);
 
std::vector<int> data;
 
void reader(int id) {
   for(;;) {
        
      while(std::atomic_fetch_sub(&cnt, 1) <= 0)
         std::atomic_fetch_add(&cnt, 1);
        
      if(!data.empty())
         std::cout << (  "reader " + std::to_string(id)
            + " sees " + std::to_string(*data.rbegin()) + '\n');
      if(data.size() == 100)
         break;
        
      std::atomic_fetch_add(&cnt, 1);
        
      std::this_thread::sleep_for(std::chrono::milliseconds(1));
   }
}
 
void writer() {
   for(int n = 0; n < 100; ++n) {
        
      while(std::atomic_fetch_sub(&cnt, N+1) != N)
         std::atomic_fetch_add(&cnt, N+1);
        
         data.push_back(n);
         std::cout << "writer pushed back " << n << '\n';
        
         std::atomic_fetch_add(&cnt, N+1);
        
         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();
   }
}

La sortie devrait être comme ça -

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