Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::atomic_fetch_add,std::atomic_fetch_add_explicit

      From cppreference.com
      <cpp‎ |atomic
       
       
      Concurrency support library
      Threads
      (C++11)
      (C++20)
      this_thread namespace
      (C++11)
      (C++11)
      (C++11)
      Cooperative cancellation
      Mutual exclusion
      Generic lock management
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Condition variables
      (C++11)
      Semaphores
      Latches and Barriers
      (C++20)
      (C++20)
      Futures
      (C++11)
      (C++11)
      (C++11)
      Safe reclamation
      Hazard pointers
      Atomic types
      (C++11)
      (C++20)
      Initialization of atomic types
      (C++11)(deprecated in C++20)
      (C++11)(deprecated in C++20)
      Memory ordering
      (C++11)(deprecated in C++26)
      Free functions for atomic operations
      atomic_fetch_addatomic_fetch_add_explicit
      (C++11)(C++11)
      Free functions for atomic flags
       
      Defined in header<atomic>
      template<class T>

      T atomic_fetch_add(std::atomic<T>* obj,

                         typenamestd::atomic<T>::difference_type arg)noexcept;
      (1)(since C++11)
      template<class T>

      T atomic_fetch_add(volatilestd::atomic<T>* obj,

                         typenamestd::atomic<T>::difference_type arg)noexcept;
      (2)(since C++11)
      template<class T>

      T atomic_fetch_add_explicit(std::atomic<T>* obj,
                                   typenamestd::atomic<T>::difference_type arg,

                                   std::memory_order order)noexcept;
      (3)(since C++11)
      template<class T>

      T atomic_fetch_add_explicit(volatilestd::atomic<T>* obj,
                                   typenamestd::atomic<T>::difference_type arg,

                                   std::memory_order order)noexcept;
      (4)(since C++11)

      Performs atomic addition. Atomically addsarg to the value pointed to byobj and returns the valueobj held previously. The operation is performed as if the following was executed:

      1,2)obj->fetch_add(arg)
      3,4)obj->fetch_add(arg, order)

      Ifstd::atomic<T> has nofetch_add member (this member is only provided forintegral,floating-point(since C++20) andpointer types exceptbool), the program is ill-formed.

      Contents

      [edit]Parameters

      obj - pointer to the atomic object to modify
      arg - the value to add to the value stored in the atomic object
      order - the memory synchronization ordering

      [edit]Return value

      The value immediately preceding the effects of this function in themodification order of*obj.

      [edit]Example

      Single-writer/multiple-reader lock can be made withstd::atomic_fetch_add. Note that this simplistic implementation is not lockout-free.

      Run this code
      #include <atomic>#include <chrono>#include <iostream>#include <string>#include <thread>#include <vector> usingnamespace std::chrono_literals; // meaning of cnt://  5: readers and writer are in race. There are no active readers or writers.//  4...0: there are 1...5 active readers, The writer is blocked.// -1: writer won the race and readers are blocked. constint N=5;// four concurrent readers are allowedstd::atomic<int> cnt(N); std::vector<int> data; void reader(int id){for(;;){// lockwhile(std::atomic_fetch_sub(&cnt,1)<=0)            std::atomic_fetch_add(&cnt,1); // readif(!data.empty())std::cout<<("reader "+std::to_string(id)+" sees "+std::to_string(*data.rbegin())+'\n');if(data.size()==25)break; // unlock        std::atomic_fetch_add(&cnt,1); // pausestd::this_thread::sleep_for(1ms);}} void writer(){for(int n=0; n<25;++n){// lockwhile(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); // pausestd::this_thread::sleep_for(1ms);}} 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 0reader 2 sees 0reader 3 sees 0reader 1 sees 0<...>reader 2 sees 24reader 4 sees 24reader 1 sees 24

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      P0558R1C++11exact type match was required because
      T was deduced from multiple arguments
      T is only deduced
      fromobj

      [edit]See also

      atomically adds the argument to the value stored in the atomic object and obtains the value held previously
      (public member function ofstd::atomic<T>)[edit]
      subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic
      (function template)[edit]
      C documentation foratomic_fetch_add,atomic_fetch_add_explicit
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/atomic/atomic_fetch_add&oldid=161340"

      [8]ページ先頭

      ©2009-2025 Movatter.jp