Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::atomic_is_lock_free, ATOMIC_xxx_LOCK_FREE

      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_is_lock_free
      (C++11)
      Free functions for atomic flags
       
      Defined in header<atomic>
      template<class T>
      bool atomic_is_lock_free(constvolatilestd::atomic<T>* obj)noexcept;
      (1)(since C++11)
      template<class T>
      bool atomic_is_lock_free(conststd::atomic<T>* obj)noexcept;
      (2)(since C++11)
      #define ATOMIC_BOOL_LOCK_FREE     /* unspecified */

      #define ATOMIC_CHAR_LOCK_FREE     /* unspecified */
      #define ATOMIC_CHAR16_T_LOCK_FREE /* unspecified */
      #define ATOMIC_CHAR32_T_LOCK_FREE /* unspecified */
      #define ATOMIC_WCHAR_T_LOCK_FREE  /* unspecified */
      #define ATOMIC_SHORT_LOCK_FREE    /* unspecified */
      #define ATOMIC_INT_LOCK_FREE      /* unspecified */
      #define ATOMIC_LONG_LOCK_FREE     /* unspecified */
      #define ATOMIC_LLONG_LOCK_FREE    /* unspecified */

      #define ATOMIC_POINTER_LOCK_FREE  /* unspecified */
      (3)(since C++11)
      #define ATOMIC_CHAR8_T_LOCK_FREE  /* unspecified */
      (4)(since C++20)
      1,2) Determines if the atomic object pointed to byobj is implemented lock-free, as if by callingobj->is_lock_free(). In any given program execution, the result of the lock-free query is the same for all atomic objects of the same type.
      3,4) Expands to an integer constant expression with value
      • 0 for the built-in atomic types that are never lock-free,
      • 1 for the built-in atomic types that aresometimes lock-free,
      • 2 for the built-in atomic types that are always lock-free.

      Contents

      [edit]Parameters

      obj - pointer to the atomic object to examine

      [edit]Return value

      true if*obj is a lock-free atomic,false otherwise.

      [edit]Notes

      All atomic types except forstd::atomic_flag may be implemented using mutexes or other locking operations, rather than using the lock-free atomic CPU instructions. Atomic types are also allowed to besometimes lock-free: for example, if only some sub-architectures support lock-free atomic access for a given type (such as theCMPXCHG16B instruction on x86-64), whether atomics are lock-free may not be known until runtime.

      The C++ standard recommends (but does not require) that lock-free atomic operations are also address-free, that is, suitable for communication between processes using shared memory.

      [edit]Example

      Run this code
      #include <atomic>#include <iostream>#include <utility> struct A{int a[4];};struct B{int x, y;}; int main(){std::atomic<A> a;std::atomic<B> b;std::cout<<std::boolalpha<<"std::atomic<A> is lock free? "<< std::atomic_is_lock_free(&a)<<'\n'<<"std::atomic<B> is lock free? "<< std::atomic_is_lock_free(&b)<<'\n';}

      Possible output:

      std::atomic<A> is lock free? falsestd::atomic<B> is lock free? true

      [edit]Defect reports

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

      DRApplied toBehavior as publishedCorrect behavior
      LWG 3249C++11atomic_is_lock_free was specified via pointers, which
      was ambiguous and might accept invalid pointer values
      specified via
      atomic objects

      [edit]See also

      checks if the atomic object is lock-free
      (public member function ofstd::atomic<T>)[edit]
      the lock-free boolean atomic type
      (class)[edit]
      [static](C++17)
      indicates that the type is always lock-free
      (public static member constant ofstd::atomic<T>)[edit]
      (deprecated in C++20)(removed in C++26)
      specializes atomic operations forstd::shared_ptr
      (function template)
      C documentation foratomic_is_lock_free
      C documentation forATOMIC_*_LOCK_FREE
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/atomic/atomic_is_lock_free&oldid=181989"

      [8]ページ先頭

      ©2009-2026 Movatter.jp