Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::atomic<T>::exchange

      From cppreference.com
      <cpp‎ |atomic‎ |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
      Free functions for atomic flags
       
       
      T exchange( T desired,std::memory_order order=
                                 std::memory_order_seq_cst)noexcept;
      (1)(since C++11)
      T exchange( T desired,std::memory_order order=
                                 std::memory_order_seq_cst)volatilenoexcept;
      (2)(since C++11)

      Atomically replaces the underlying value withdesired (a read-modify-write operation). Memory is affected according to the value oforder.

      It is deprecated ifstd::atomic<T>::is_always_lock_free isfalse and overload(2) participates in overload resolution.

      (since C++20)

      Contents

      [edit]Parameters

      desired - value to assign
      order - memory order constraints to enforce

      [edit]Return value

      The value of the atomic variable before the call.

      [edit]Example

      Run this code
      #include <algorithm>#include <atomic>#include <cstddef>#include <iostream>#include <syncstream>#include <thread>#include <vector> int main(){constexprint thread_count{5};constexprint sum{5}; std::atomic<int> atom{0};std::atomic<int> counter{0}; auto increment_to_sum=[&](constint id){for(int next=0; next< sum;){// each thread is writing a value from its own knowledgeconstint current= atom.exchange(next);            counter++;// sync writing to prevent from interrupting by other threadsstd::osyncstream(std::cout)<<"Thread #"<< id<<" (id="<<std::this_thread::get_id()<<") wrote "<< next<<" replacing the old value "<< current<<".\n";            next=std::max(current, next)+1;}}; std::vector<std::thread> v;for(std::size_t i=0; i< thread_count;++i)        v.emplace_back(increment_to_sum, i); for(auto& tr: v)        tr.join(); std::cout<< thread_count<<" threads take "<< counter<<" times in total to "<<"increment 0 to "<< sum<<".\n";}

      Possible output:

      Thread #1 (id=139722332333824) wrote 0 replacing the old value 0.Thread #2 (id=139722323941120) wrote 0 replacing the old value 0.Thread #1 (id=139722332333824) wrote 1 replacing the old value 0.Thread #1 (id=139722332333824) wrote 2 replacing the old value 1.Thread #1 (id=139722332333824) wrote 3 replacing the old value 2.Thread #1 (id=139722332333824) wrote 4 replacing the old value 3.Thread #0 (id=139722340726528) wrote 0 replacing the old value 0.Thread #3 (id=139722315548416) wrote 0 replacing the old value 0.Thread #3 (id=139722315548416) wrote 1 replacing the old value 4.Thread #0 (id=139722340726528) wrote 1 replacing the old value 1.Thread #4 (id=139722307155712) wrote 0 replacing the old value 1.Thread #4 (id=139722307155712) wrote 2 replacing the old value 2.Thread #4 (id=139722307155712) wrote 3 replacing the old value 2.Thread #4 (id=139722307155712) wrote 4 replacing the old value 3.Thread #2 (id=139722323941120) wrote 1 replacing the old value 0.Thread #0 (id=139722340726528) wrote 2 replacing the old value 1.Thread #2 (id=139722323941120) wrote 2 replacing the old value 4.Thread #0 (id=139722340726528) wrote 3 replacing the old value 2.Thread #0 (id=139722340726528) wrote 4 replacing the old value 3.5 threads take 19 times in total to increment 0 to 5.

      [edit]See also

      atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic
      (function template)[edit]
      (C++14)
      replaces the argument with a new value and returns its previous value
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/atomic/atomic/exchange&oldid=159327"

      [8]ページ先頭

      ©2009-2025 Movatter.jp