Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/thread/shared lock"

From cppreference.com
< cpp‎ | thread
m (link to ja)
m (~)
 
(4 intermediate revisions by 4 users not shown)
Line 1: Line 1:
 
{{cpp/title|shared_lock}}
 
{{cpp/title|shared_lock}}
 
{{cpp/thread/shared_lock/navbar}}
 
{{cpp/thread/shared_lock/navbar}}
−
{{ddcl | header=shared_mutex | since=c++14 | 1=
+
{{ddcl|header=shared_mutex|since=c++14|
 
template< class Mutex >
 
template< class Mutex >
 
class shared_lock;
 
class shared_lock;
 
}}
 
}}
  
−
The class {{tt|shared_lock}} is a general-purpose shared mutex ownership wrapper allowing deferred locking, timed locking and transfer of lock ownership. Locking a {{tt|shared_lock}} locks the associated shared mutex in shared mode (to lock it in exclusive mode, {{lc|std::unique_lock}} can be used)
+
The class {{tt|shared_lock}} is a general-purpose shared mutex ownership wrapper allowing deferred locking, timed locking and transfer of lock ownership. Locking a {{tt|shared_lock}} locks the associated shared mutex in shared mode (to lock it in exclusive mode, {{lc|std::unique_lock}} can be used).
  
−
The {{tt|shared_lock}} class is movable, but not copyable -- it meets the requirements of {{named req|MoveConstructible}} and {{named req|MoveAssignable}} but not of {{named req|CopyConstructible}} or {{named req|CopyAssignable}}.
+
The {{tt|shared_lock}} class is movable, but not copyable &ndash; it meets the requirements of {{named req|MoveConstructible}} and {{named req|MoveAssignable}} but not of {{named req|CopyConstructible}} or {{named req|CopyAssignable}}.
  
−
In order to wait in a shared mutex in shared ownership mode, {{lc|std::condition_variable_any}} can be used ({{lc|std::condition_variable}} requires {{lc|std::unique_lock}} and so can only wait in unique ownership mode)
+
{{tt|shared_lock}} meets the {{named req|Lockable}} requirements. If {{tt|Mutex}} meets the {{named req|SharedTimedLockable}} requirements, {{tt|shared_lock}} also meets {{named req|TimedLockable}} requirements.
 +
 
 +
In order to wait in a shared mutex in shared ownership mode, {{lc|std::condition_variable_any}} can be used ({{lc|std::condition_variable}} requires {{lc|std::unique_lock}} and so can only wait in unique ownership mode).
  
 
===Template parameters===
 
===Template parameters===
 
{{par begin}}
 
{{par begin}}
−
{{par | Mutex | the type of the shared mutex to lock. The type must meet the {{named req|SharedMutex}} requirements}}
+
{{par|Mutex|the type of the shared mutex to lock. The type must meet the {{named req|SharedLockable}} requirements<!-- P2160R1 -->}}
 
{{par end}}
 
{{par end}}
  
 
===Member types===
 
===Member types===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc hitem | Type | Definition}}
+
{{dsc hitem|Type|Definition}}
−
{{dsc | {{tt|mutex_type}} | {{c|Mutex}}}}
+
{{dsc|{{tt|mutex_type}}|{{tt|Mutex}}}}
 
{{dsc end}}
 
{{dsc end}}
  
 
===Member functions===
 
===Member functions===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/thread/shared_lock/dsc constructor}}
+
{{dsc inc|cpp/thread/shared_lock/dsc constructor}}
−
{{dsc inc | cpp/thread/shared_lock/dsc destructor}}
+
{{dsc inc|cpp/thread/shared_lock/dsc destructor}}
−
{{dsc inc | cpp/thread/shared_lock/dsc operator{{=}}}}
+
{{dsc inc|cpp/thread/shared_lock/dsc operator{{=}}}}
  
−
{{dsc h2 | Shared locking}}
+
{{dsc h2|Shared locking}}
−
{{dsc inc | cpp/thread/shared_lock/dsc lock}}
+
{{dsc inc|cpp/thread/shared_lock/dsc lock}}
−
{{dsc inc | cpp/thread/shared_lock/dsc try_lock}}
+
{{dsc inc|cpp/thread/shared_lock/dsc try_lock}}
−
{{dsc inc | cpp/thread/shared_lock/dsc try_lock_for}}
+
{{dsc inc|cpp/thread/shared_lock/dsc try_lock_for}}
−
{{dsc inc | cpp/thread/shared_lock/dsc try_lock_until}}
+
{{dsc inc|cpp/thread/shared_lock/dsc try_lock_until}}
−
{{dsc inc | cpp/thread/shared_lock/dsc unlock}}
+
{{dsc inc|cpp/thread/shared_lock/dsc unlock}}
  
−
{{dsc h2 | Modifiers}}
+
{{dsc h2|Modifiers}}
−
{{dsc inc | cpp/thread/shared_lock/dsc swap}}
+
{{dsc inc|cpp/thread/shared_lock/dsc swap}}
−
{{dsc inc | cpp/thread/shared_lock/dsc release}}
+
{{dsc inc|cpp/thread/shared_lock/dsc release}}
  
−
{{dsc h2 | Observers}}
+
{{dsc h2|Observers}}
−
{{dsc inc | cpp/thread/shared_lock/dsc mutex}}
+
{{dsc inc|cpp/thread/shared_lock/dsc mutex}}
−
{{dsc inc | cpp/thread/shared_lock/dsc owns_lock}}
+
{{dsc inc|cpp/thread/shared_lock/dsc owns_lock}}
−
{{dsc inc | cpp/thread/shared_lock/dsc operator bool}}
+
{{dsc inc|cpp/thread/shared_lock/dsc operator bool}}
 
{{dsc end}}
 
{{dsc end}}
  
 
===Non-member functions===
 
===Non-member functions===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/thread/shared_lock/dsc swap2}}
+
{{dsc inc|cpp/thread/shared_lock/dsc swap2}}
 
{{dsc end}}
 
{{dsc end}}
  
−
=== Defect reports ===
+
===Defect reports===
 
{{dr list begin}}
 
{{dr list begin}}
−
{{dr list item|wg=lwg|dr=2981|std=C++17|before=redundant deduction guide from {{tt|shared_lock<Mutex>}} was provided | after=removed}}
+
{{dr list item|wg=lwg|dr=2981|std=C++17|before=redundant deduction guide from {{tt|shared_lock<Mutex>}} was provided|after=removed}}
 
{{dr list end}}
 
{{dr list end}}
  
−
 
+
{{langlinks|de|es|ja|ru|zh}}
−
{{langlinks|ja|zh}}
+

Latest revision as of 03:17, 18 July 2024

 
C++
 
Concurrency support library
Threads
(C++11)
(C++20)
(C++17)(C++17)
this_thread namespace
(C++11)
(C++11)
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
(C++11)
(C++11)
(C++17)
Generic lock management
(C++11)
(C++11)
(C++17)
(C++11)
shared_lock
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20)(C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe Reclamation
(C++26)
(C++26)
(C++26)
Hazard Pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11)(deprecated in C++20)
(C++11)(deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11)
(C++11)
(C++11)
Free functions for atomic operations
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++26)(C++26)
(C++26)(C++26)
(C++11)
(C++20)(C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11)(C++11)
(C++11)(C++11)
(C++20)(C++20)
(C++20)(C++20)
(C++20)
(C++20)
 
std::shared_lock
 
Defined in header <shared_mutex>
template< class Mutex >
class shared_lock;
 (since C++14)

The class shared_lock is a general-purpose shared mutex ownership wrapper allowing deferred locking, timed locking and transfer of lock ownership. Locking a shared_lock locks the associated shared mutex in shared mode (to lock it in exclusive mode, std::unique_lock can be used).

The shared_lock class is movable, but not copyable – it meets the requirements of MoveConstructible and MoveAssignable but not of CopyConstructible or CopyAssignable.

shared_lock meets the Lockable requirements. If Mutex meets the SharedTimedLockable requirements, shared_lock also meets TimedLockable requirements.

In order to wait in a shared mutex in shared ownership mode, std::condition_variable_any can be used (std::condition_variable requires std::unique_lock and so can only wait in unique ownership mode).

Contents

[edit] Template parameters

Mutex - the type of the shared mutex to lock. The type must meet the SharedLockable requirements

[edit] Member types

Type Definition
mutex_type Mutex

[edit] Member functions

 constructs a shared_lock, optionally locking the supplied mutex
(public member function) [edit]
unlocks the associated mutex
(public member function) [edit]
unlocks the mutex, if owned, and acquires ownership of another
(public member function) [edit]
Shared locking
locks the associated mutex
(public member function) [edit]
tries to lock the associated mutex
(public member function) [edit]
tries to lock the associated mutex, for the specified duration
(public member function) [edit]
tries to lock the associated mutex, until a specified time point
(public member function) [edit]
unlocks the associated mutex
(public member function) [edit]
Modifiers
swaps the data members with another shared_lock
(public member function) [edit]
disassociates the mutex without unlocking
(public member function) [edit]
Observers
returns a pointer to the associated mutex
(public member function) [edit]
tests whether the lock owns its associated mutex
(public member function) [edit]
tests whether the lock owns its associated mutex
(public member function) [edit]

[edit] Non-member functions

(C++14)
 specializes the std::swap algorithm
(function template) [edit]

[edit] Defect reports

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

DR Applied to Behavior as published Correct behavior
LWG 2981 C++17 redundant deduction guide from shared_lock<Mutex> was provided removed
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/thread/shared_lock&oldid=173774"