Namespaces
Variants

    cpp/named req/BasicLockable: Difference between revisions

    From cppreference.com
    ← Older edit
    Space Mission (talk | contribs)
    19,873 edits
    m →Library types: +(hidden yet) rcu_domain.
    Space Mission (talk | contribs)
    19,873 edits
    m →Standard library: unified the section name.
     
    Line 24: Line 24:
    A lock on an object is said to be ''non-shared lock'' if it is acquired by a call to {{tt|lock}}, {{tt|try_lock}}, {{tt|try_lock_for}}, or {{tt|try_lock_until}} member function.
    A lock on an object is said to be ''non-shared lock'' if it is acquired by a call to {{tt|lock}}, {{tt|try_lock}}, {{tt|try_lock_for}}, or {{tt|try_lock_until}} member function.


    ===Library types===
    ======
    The following standard library types satisfy {{named req/core|BasicLockable}} requirements:
    The following standard library types satisfy {{named req/core|BasicLockable}} requirements:
    {{dsc begin}}
    {{dsc begin}}

    Latest revision as of 19:46, 21 November 2024

     
    C++
     
    C++ named requirements
     

    The BasicLockable requirements describe the minimal characteristics of types that provide exclusive blocking semantics for execution agents (i.e. threads).

    Requirements

    For type L to be BasicLockable, the following conditions have to be satisfied for an object m of type L:

    Expression Preconditions Effects
    m.lock() Blocks until a lock can be acquired for the current execution agent (thread, process, task). If an exception is thrown, no lock is acquired.
    m.unlock() The current execution agent holds a non-shared lock on m. Releases the non-shared lock held by the execution agent.

    Throws no exceptions.

    Non-shared locks

    A lock on an object is said to be non-shared lock if it is acquired by a call to lock, try_lock, try_lock_for, or try_lock_until member function.

    Standard library

    The following standard library types satisfy BasicLockable requirements:

    (C++11)
    		 provides basic mutual exclusion facility
    (class) [edit]
    (C++11)
    		 provides mutual exclusion facility which can be locked recursively by the same thread
    (class) [edit]
    (C++11)
    		 provides mutual exclusion facility which can be locked recursively
    by the same thread and implements locking with a timeout
    (class) [edit]
    (C++17)
    		 provides shared mutual exclusion facility
    (class) [edit]
    (C++14)
    		 provides shared mutual exclusion facility and implements locking with a timeout
    (class) [edit]
    (C++11)
    		 provides mutual exclusion facility which implements locking with a timeout
    (class) [edit]

    See also