Cpp-standard-library-cpp-atomic-fetch-and

C ++アトミックライブラリ-フェッチアンド

説明

アトミックオブジェクトを論理ANDの結果と非アトミック引数で置き換え、アトミックの前の値を取得します。

宣言

以下は、std

atomic_fetch_andの宣言です。

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

C 11

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

以下は、std

atomic_fetch_and_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_and_explicit( volatile std::atomic<Integral>* obj,
                                    Integral arg,
                                    std::memory_order order);

パラメーター

• obj -変更するアトミックオブジェクトへのポインタで使用されます。
• desr -値をアトミックオブジェクトに格納するために使用されます。
• order -この操作のメモリ順序を同期するために使用されます。

戻り値

この関数の効果の直前の値を* objの変更順で返します。

例外

*No-noexcept* -このメンバー関数は例外をスローしません。

例

以下のstd

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