Bibliothèque atomique C ++ - Récupérer ou

La description

Il remplace l'objet atomique par le résultat du OU logique par un argument non atomique et obtient la valeur précédente de l'atome.

Déclaration

Voici la déclaration pour std :: atomic_fetch_or.

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

C ++ 11

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

Voici la déclaration pour std :: atomic_fetch_or_explicit.

template< class Integral >
Integral atomic_fetch_and_explicit( std::atomic<Integral>* obj, 
                                    Integral arg, 
                                    std::memory_order order);

C ++ 11

template< class Integral >
Integral atomic_fetch_or_explicit( std::atomic<Integral>* obj,
                                   Integral 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_or_explicit.

#include <iostream>
#include <atomic>
#include <thread>
#include <chrono>
#include <functional>

class Semaphore {
   std::atomic_char m_signaled;
   public:
      Semaphore(bool initial = false) {
         m_signaled = initial;
   }

   void take() {
      while (!std::atomic_fetch_and(&m_signaled, false)) {
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
      }
   }

   void put() {
      std::atomic_fetch_or(&m_signaled, true);
   }
};
 
class ThreadedCounter {
   static const int N = 100;
   static const int REPORT_INTERVAL = 10;
   int m_count;
   bool m_done;
   Semaphore m_count_sem;
   Semaphore m_print_sem;

   void count_up() {
      for (m_count = 1; m_count <= N; m_count++) {
         if (m_count % REPORT_INTERVAL == 0) {
            if (m_count == N) m_done = true;
            m_print_sem.put();
            m_count_sem.take();
         }
      }
      std::cout << "count_up() done\n";
      m_done = true;
      m_print_sem.put();
   }
 
   void print_count() {
      do {
         m_print_sem.take();
         std::cout << m_count << '\n';
         m_count_sem.put();
      } while (!m_done);
      std::cout << "print_count() done\n";
   }
 
   public:
      ThreadedCounter() : m_done(false) {}
      void run() {
         auto print_thread = std::thread(&ThreadedCounter::print_count, this);
         auto count_thread = std::thread(&ThreadedCounter::count_up, this);
         print_thread.join();
         count_thread.join();
      }
};
 
int main() {
   ThreadedCounter m_counter;
   m_counter.run();
}