...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
Handling mutexes in C++ is an excellent tutorial. You need just replace std and ting by boost.
Mutex, Lock, Condition Variable Rationale adds rationale for the design decisions made for mutexes, locks and condition variables.
In addition to the C++11 standard locks, Boost.Thread provides other locks and some utilities that help the user to make their code thread-safe.
Note | |
---|---|
This tutorial is an adaptation of chapter Concurrency of the Object-Oriented Programming in the BETA Programming Language and of the paper of Andrei Alexandrescu "Multithreading and the C++ Type System" to the Boost library. |
Consider, for example, modeling a bank account class that supports simultaneous deposits and withdrawals from multiple locations (arguably the "Hello, World" of multithreaded programming).
From here a component is a model of the Callable
concept.
I C++11 (Boost) concurrent execution of a component is obtained by means
of the std::thread
(boost::thread
):
boost::thread thread1(S);
where S
is a model of
Callable
. The meaning
of this expression is that execution of S()
will take place concurrently with the
current thread of execution executing the expression.
The following example includes a bank account of a person (Joe) and two components, one corresponding to a bank agent depositing money in Joe's account, and one representing Joe. Joe will only be withdrawing money from the account:
class BankAccount; BankAccount JoesAccount; void bankAgent() { for (int i =10; i>0; --i) { //... JoesAccount.Deposit(500); //... } } void Joe() { for (int i =10; i>0; --i) { //... int myPocket = JoesAccount.Withdraw(100); std::cout << myPocket << std::endl; //... } } int main() { //... boost::thread thread1(bankAgent); // start concurrent execution of bankAgent boost::thread thread2(Joe); // start concurrent execution of Joe thread1.join(); thread2.join(); return 0; }
From time to time, the bankAgent
will deposit $500 in JoesAccount
.
Joe
will similarly withdraw
$100 from his account. These sentences describe that the bankAgent
and Joe
are executed concurrently.
The above example works well as long as the components bankAgent
and Joe
doesn't access JoesAccount
at the same time. There is, however, no guarantee that this will not
happen. We may use a mutex to guarantee exclusive access to each bank.
class BankAccount { boost::mutex mtx_; int balance_; public: void Deposit(int amount) { mtx_.lock(); balance_ += amount; mtx_.unlock(); } void Withdraw(int amount) { mtx_.lock(); balance_ -= amount; mtx_.unlock(); } int GetBalance() { mtx_.lock(); int b = balance_; mtx_.unlock(); return b; } };
Execution of the Deposit
and Withdraw
operations
will no longer be able to make simultaneous access to balance.
A mutex is a simple and basic mechanism for obtaining synchronization. In the above example it is relatively easy to be convinced that the synchronization works correctly (in the absence of exception). In a system with several concurrent objects and several shared objects, it may be difficult to describe synchronization by means of mutexes. Programs that make heavy use of mutexes may be difficult to read and write. Instead, we shall introduce a number of generic classes for handling more complicated forms of synchronization and communication.
With the RAII idiom we can simplify a lot this using the scoped locks.
In the code below, guard's constructor locks the passed-in object mtx_
, and guard's destructor unlocks
mtx_
.
class BankAccount { boost::mutex mtx_; // explicit mutex declaration int balance_; public: void Deposit(int amount) { boost::lock_guard<boost::mutex> guard(mtx_); balance_ += amount; } void Withdraw(int amount) { boost::lock_guard<boost::mutex> guard(mtx_); balance_ -= amount; } int GetBalance() { boost::lock_guard<boost::mutex> guard(mtx_); return balance_; } };
The object-level locking idiom doesn't cover the entire richness of a threading model. For example, the model above is quite deadlock-prone when you try to coordinate multi-object transactions. Nonetheless, object-level locking is useful in many cases, and in combination with other mechanisms can provide a satisfactory solution to many threaded access problems in object-oriented programs.
The BankAccount class above uses internal locking. Basically, a class that uses internal locking guarantees that any concurrent calls to its public member functions don't corrupt an instance of that class. This is typically ensured by having each public member function acquire a lock on the object upon entry. This way, for any given object of that class, there can be only one member function call active at any moment, so the operations are nicely serialized.
This approach is reasonably easy to implement and has an attractive simplicity. Unfortunately, "simple" might sometimes morph into "simplistic."
Internal locking is insufficient for many real-world synchronization tasks. Imagine that you want to implement an ATM withdrawal transaction with the BankAccount class. The requirements are simple. The ATM transaction consists of two withdrawals-one for the actual money and one for the $2 commission. The two withdrawals must appear in strict sequence; that is, no other transaction can exist between them.
The obvious implementation is erratic:
void ATMWithdrawal(BankAccount& acct, int sum) { acct.Withdraw(sum); // preemption possible acct.Withdraw(2); }
The problem is that between the two calls above, another thread can perform another operation on the account, thus breaking the second design requirement.
In an attempt to solve this problem, let's lock the account from the outside during the two operations:
void ATMWithdrawal(BankAccount& acct, int sum) { boost::lock_guard<boost::mutex> guard(acct.mtx_); 1 acct.Withdraw(sum); acct.Withdraw(2); }
Notice that the code above doesn't compile, the mtx_
field is private. We have two possibilities:
mtx_
public
which seems odd
BankAccount
lockable by adding the lock/unlock functions
We can add these functions explicitly
class BankAccount { boost::mutex mtx_; int balance_; public: void Deposit(int amount) { boost::lock_guard<boost::mutex> guard(mtx_); balance_ += amount; } void Withdraw(int amount) { boost::lock_guard<boost::mutex> guard(mtx_); balance_ -= amount; } void lock() { mtx_.lock(); } void unlock() { mtx_.unlock(); } };
or inheriting from a class which add these lockable functions.
The basic_lockable_adapter
class helps to define the BankAccount
class as
class BankAccount : public basic_lockable_adapter<mutex> { int balance_; public: void Deposit(int amount) { boost::lock_guard<BankAccount> guard(*this); balance_ += amount; } void Withdraw(int amount) { boost::lock_guard<BankAccount> guard(*this); balance_ -= amount; } int GetBalance() { boost::lock_guard<BankAccount> guard(*this); return balance_; } };
and the code that doesn't compiles becomes
void ATMWithdrawal(BankAccount& acct, int sum) { boost::lock_guard<BankAccount> guard(acct); acct.Withdraw(sum); acct.Withdraw(2); }
Notice that now acct is being locked by Withdraw after it has already been locked by guard. When running such code, one of two things happens.
As boost::mutex
is not recursive, we need to
use its recursive version boost::recursive_mutex
.
class BankAccount : public basic_lockable_adapter<recursive_mutex> { // ... };
The caller-ensured locking approach is more flexible and the most efficient, but very dangerous. In an implementation using caller-ensured locking, BankAccount still holds a mutex, but its member functions don't manipulate it at all. Deposit and Withdraw are not thread-safe anymore. Instead, the client code is responsible for locking BankAccount properly.
class BankAccount : public basic_lockable_adapter<boost:mutex> { int balance_; public: void Deposit(int amount) { balance_ += amount; } void Withdraw(int amount) { balance_ -= amount; } };
Obviously, the caller-ensured locking approach has a safety problem. BankAccount's implementation code is finite, and easy to reach and maintain, but there's an unbounded amount of client code that manipulates BankAccount objects. In designing applications, it's important to differentiate between requirements imposed on bounded code and unbounded code. If your class makes undue requirements on unbounded code, that's usually a sign that encapsulation is out the window.
To conclude, if in designing a multi-threaded class you settle on internal locking, you expose yourself to inefficiency or deadlocks. On the other hand, if you rely on caller-provided locking, you make your class error-prone and difficult to use. Finally, external locking completely avoids the issue by leaving it all to the client code.
Note | |
---|---|
This tutorial is an adaptation of the paper by Andrei Alexandrescu "Multithreading and the C++ Type System" to the Boost library. |
So what to do? Ideally, the BankAccount class should do the following:
Let's make a worthwhile observation: Whenever you lock a BankAccount,
you do so by using a lock_guard<BankAccount>
object. Turning this statement around,
wherever there's a lock_guard<BankAccount>
, there's also a locked BankAccount
somewhere. Thus, you can
think of-and use-a lock_guard<BankAccount>
object as a permit. Owning a lock_guard<BankAccount>
gives you rights to do certain things. The lock_guard<BankAccount>
object should not be copied or aliased
(it's not a transmissible permit).
BankAccount
object stays locked.
lock_guard<BankAccount>
is destroyed, the BankAccount
's mutex is released.
The net effect is that at any point in your code, having access to a
lock_guard<BankAccount>
object guarantees that a BankAccount
is locked. (You don't know exactly which BankAccount
is locked, however-an issue that we'll address soon.)
For now, let's make a couple of enhancements to the lock_guard
class template defined in Boost.Thread. We'll call the enhanced version
strict_lock
. Essentially,
a strict_lock
's role
is only to live on the stack as an automatic variable. strict_lock
must adhere to a non-copy
and non-alias policy. strict_lock
disables copying by making the copy constructor and the assignment operator
private.
template <typename Lockable> class strict_lock { public: typedef Lockable lockable_type; explicit strict_lock(lockable_type& obj) : obj_(obj) { obj.lock(); // locks on construction } strict_lock() = delete; strict_lock(strict_lock const&) = delete; strict_lock& operator=(strict_lock const&) = delete; ~strict_lock() { obj_.unlock(); } // unlocks on destruction bool owns_lock(mutex_type const* l) const noexcept // strict lockers specific function { return l == &obj_; } private: lockable_type& obj_; };
Silence can be sometimes louder than words-what's forbidden to do with
a strict_lock
is as important
as what you can do. Let's see what you can and what you cannot do with
a strict_lock
instantiation:
strict_lock<T>
only starting from a valid T
object. Notice that there is no other way you can create a strict_lock<T>
.
BankAccount myAccount("John Doe", "123-45-6789"); strict_lock<BankAccount> myLock(myAccount); // ok
strict_lock
s
to one another. In particular, you cannot pass strict_lock
s
by value to functions or have them returned by functions:
extern strict_lock<BankAccount> Foo(); // compile-time error extern void Bar(strict_lock<BankAccount>); // compile-time error
strict_lock
s
by reference to and from functions:
// ok, Foo returns a reference to strict_lock<BankAccount> extern strict_lock<BankAccount>& Foo(); // ok, Bar takes a reference to strict_lock<BankAccount> extern void Bar(strict_lock<BankAccount>&);
All these rules were put in place with one purpose-enforcing that owning
a strict_lock<T>
is a reasonably strong guarantee that
Now that we have such a strict strict_lock
,
how do we harness its power in defining a safe, flexible interface for
BankAccount? The idea is as follows:
strict_lock<BankAccount>
. The first version is internally
locked; the second one requires external locking. External locking
is enforced at compile time by requiring client code to create a
strict_lock<BankAccount>
object.
A little code is worth 1,000 words, a (hacked into) saying goes, so here's the new BankAccount class:
class BankAccount : public basic_lockable_adapter<boost:recursive_mutex> { int balance_; public: void Deposit(int amount, strict_lock<BankAccount>&) { // Externally locked balance_ += amount; } void Deposit(int amount) { strict_lock<boost:mutex> guard(*this); // Internally locked Deposit(amount, guard); } void Withdraw(int amount, strict_lock<BankAccount>&) { // Externally locked balance_ -= amount; } void Withdraw(int amount) { strict_lock<boost:mutex> guard(*this); // Internally locked Withdraw(amount, guard); } };
Now, if you want the benefit of internal locking, you simply call Deposit(int)
and
Withdraw(int)
.
If you want to use external locking, you lock the object by constructing
a strict_lock<BankAccount>
and then you call Deposit(int,
strict_lock<BankAccount>&)
and Withdraw(int, strict_lock<BankAccount>&)
.
For example, here's the ATMWithdrawal
function implemented correctly:
void ATMWithdrawal(BankAccount& acct, int sum) { strict_lock<BankAccount> guard(acct); acct.Withdraw(sum, guard); acct.Withdraw(2, guard); }
This function has the best of both worlds-it's reasonably safe and efficient at the same time.
It's worth noting that strict_lock
being a template gives extra safety compared to a straight polymorphic
approach. In such a design, BankAccount would derive from a Lockable
interface. strict_lock
would manipulate Lockable references so there's no need for templates.
This approach is sound; however, it provides fewer compile-time guarantees.
Having a strict_lock
object would only tell that some object derived from Lockable is currently
locked. In the templated approach, having a strict_lock<BankAccount>
gives a stronger guarantee-it's a
BankAccount
that stays
locked.
There's a weasel word in there-I mentioned that ATMWithdrawal is reasonably
safe. It's not really safe because there's no enforcement that the strict_lock<BankAccount>
object locks the appropriate BankAccount object. The type system only
ensures that some BankAccount object is locked. For example, consider
the following phony implementation of ATMWithdrawal:
void ATMWithdrawal(BankAccount& acct, int sum) { BankAccount fakeAcct("John Doe", "123-45-6789"); strict_lock<BankAccount> guard(fakeAcct); acct.Withdraw(sum, guard); acct.Withdraw(2, guard); }
This code compiles warning-free but obviously doesn't do the right thing-it locks one account and uses another.
It's important to understand what can be enforced within the realm of
the C++ type system and what needs to be enforced at runtime. The mechanism
we've put in place so far ensures that some BankAccount object is locked
during the call to BankAccount::Withdraw(int,
strict_lock<BankAccount>&)
.
We must enforce at runtime exactly what object is locked.
If our scheme still needs runtime checks, how is it useful? An unwary or malicious programmer can easily lock the wrong object and manipulate any BankAccount without actually locking it.
First, let's get the malice issue out of the way. C is a language that requires a lot of attention and discipline from the programmer. C++ made some progress by asking a little less of those, while still fundamentally trusting the programmer. These languages are not concerned with malice (as Java is, for example). After all, you can break any C/C++ design simply by using casts "appropriately" (if appropriately is an, er, appropriate word in this context).
The scheme is useful because the likelihood of a programmer forgetting about any locking whatsoever is much greater than the likelihood of a programmer who does remember about locking, but locks the wrong object.
Using strict_lock
permits
compile-time checking of the most common source of errors, and runtime
checking of the less frequent problem.
Let's see how to enforce that the appropriate BankAccount object is locked.
First, we need to add a member function to the strict_lock
class template. The bool strict_lock<T>::owns_lock(Loclable*)
function returns a reference to the locked object.
template <class Lockable> class strict_lock { ... as before ... public: bool owns_lock(Lockable* mtx) const { return mtx==&obj_; } };
Second, BankAccount needs to use this function compare the locked object against this:
class BankAccount { : public basic_lockable_adapter<boost::recursive_mutex> int balance_; public: void Deposit(int amount, strict_lock<BankAccount>& guard) { // Externally locked if (!guard.owns_lock(*this)) throw "Locking Error: Wrong Object Locked"; balance_ += amount; } // ... };
The overhead incurred by the test above is much lower than locking a recursive mutex for the second time.
Now let's assume that BankAccount doesn't use its own locking at all, and has only a thread-neutral implementation:
class BankAccount { int balance_; public: void Deposit(int amount) { balance_ += amount; } void Withdraw(int amount) { balance_ -= amount; } };
Now you can use BankAccount in single-threaded and multi-threaded applications alike, but you need to provide your own synchronization in the latter case.
Say we have an AccountManager class that holds and manipulates a BankAccount object:
class AccountManager : public basic_lockable_adapter<boost::mutex> { BankAccount checkingAcct_; BankAccount savingsAcct_; ... };
Let's also assume that, by design, AccountManager must stay locked while accessing its BankAccount members. The question is, how can we express this design constraint using the C++ type system? How can we state "You have access to this BankAccount object only after locking its parent AccountManager object"?
The solution is to use a little bridge template externally_locked
that controls access to a BankAccount.
template <typename T, typename Lockable> class externally_locked { BOOST_CONCEPT_ASSERT((LockableConcept<Lockable>)); public: externally_locked(T& obj, Lockable& lockable) : obj_(obj) , lockable_(lockable) {} externally_locked(Lockable& lockable) : obj_() , lockable_(lockable) {} T& get(strict_lock<Lockable>& lock) { #ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED if (!lock.owns_lock(&lockable_)) throw lock_error(); run time check throw if not locks the same #endif return obj_; } void set(const T& obj, Lockable& lockable) { obj_ = obj; lockable_=lockable; } private: T obj_; Lockable& lockable_; };
externally_locked
cloaks
an object of type T, and actually provides full access to that object
through the get and set member functions, provided you pass a reference
to a strict_lock<Owner>
object.
Instead of making checkingAcct_
and savingsAcct_
of type
BankAccount
, AccountManager
holds objects of type
externally_locked<BankAccount,
AccountManager>
:
class AccountManager : public basic_lockable_adapter<thread_mutex> { public: typedef basic_lockable_adapter<thread_mutex> lockable_base_type; AccountManager() : checkingAcct_(*this) , savingsAcct_(*this) {} inline void Checking2Savings(int amount); inline void AMoreComplicatedChecking2Savings(int amount); private: externally_locked<BankAccount, AccountManager> checkingAcct_; externally_locked<BankAccount, AccountManager> savingsAcct_; };
The pattern is the same as before - to access the BankAccount object
cloaked by checkingAcct_
,
you need to call get
.
To call get
, you need
to pass it a strict_lock<AccountManager>
. The one thing you have to take care
of is to not hold pointers or references you obtained by calling get
. If you do that, make sure that
you don't use them after the strict_lock has been destroyed. That is,
if you alias the cloaked objects, you're back from "the compiler
takes care of that" mode to "you must pay attention" mode.
Typically, you use externally_locked
as shown below. Suppose you want to execute an atomic transfer from your
checking account to your savings account:
void AccountManager::Checking2Savings(int amount) { strict_lock<AccountManager> guard(*this); checkingAcct_.get(guard).Withdraw(amount); savingsAcct_.get(guard).Deposit(amount); }
We achieved two important goals. First, the declaration of checkingAcct_
and savingsAcct_
makes it clear to the code reader that that variable is protected by
a lock on an AccountManager. Second, the design makes it impossible to
manipulate the two accounts without actually locking a BankAccount.
externally_locked
is
what could be called active documentation.
Now imagine that the AccountManager function needs to take a unique_lock
in order to reduce the
critical regions. And at some time it needs to access to the checkingAcct_
. As unique_lock
is not a strict lock the following code doesn't compile:
void AccountManager::AMoreComplicatedChecking2Savings(int amount) { unique_lock<AccountManager> guard(*this, defer_lock); if (some_condition()) { guard.lock(); } checkingAcct_.get(guard).Withdraw(amount); // COMPILE ERROR savingsAcct_.get(guard).Deposit(amount); // COMPILE ERROR do_something_else(); }
We need a way to transfer the ownership from the unique_lock
to a strict_lock
during
the time we are working with savingsAcct_
and then restore the ownership on unique_lock
.
void AccountManager::AMoreComplicatedChecking2Savings(int amount) { unique_lock<AccountManager> guard1(*this, defer_lock); if (some_condition()) { guard1.lock(); } { strict_lock<AccountManager> guard(guard1); checkingAcct_.get(guard).Withdraw(amount); savingsAcct_.get(guard).Deposit(amount); } guard1.unlock(); }
In order to make this code compilable we need to store either a Lockable
or a unique_lock<Lockable>
reference depending on the constructor. We also need to store which kind
of reference we have stored, and in the destructor call either to the
Lockable unlock
or restore
the ownership.
This seems too complicated to me. Another possibility is to define a
nested strict lock class. The drawback is that instead of having only
one strict lock we have two and we need either to duplicate every function
taking a strict_lock
or make these function templates. The problem with template functions
is that we don't profit anymore of the C++ type system. We must add some
static metafunction that checks that the Locker parameter is a strict
lock. The problem is that we can not really check this or can we?. The
is_strict_lock
metafunction
must be specialized by the strict lock developer. We need to believe
it "sur parole". The advantage is that now we can manage with
more than two strict locks without changing our code. This is really
nice.
Now we need to state that both classes are strict_lock
s.
template <typename Locker> struct is_strict_lock : mpl::false_ {}; template <typename Lockable> struct is_strict_lock<strict_lock<Lockable> > : mpl::true_ {} template <typename Locker> struct is_strict_lock<nested_strict_lock<Locker> > : mpl::true_ {}
Well let me show what this nested_strict_lock
class looks like and the impacts on the externally_locked
class and the AccountManager::AMoreComplicatedFunction
function.
First nested_strict_lock
class will store on a temporary lock the Locker
,
and transfer the lock ownership on the constructor. On destruction it
will restore the ownership. Note the use of lock_traits
and that the Locker
needs
to have a reference to the mutex otherwise and exception is thrown.
template <typename Locker > class nested_strict_lock { BOOST_CONCEPT_ASSERT((MovableLockerConcept<Locker>)); public: typedef typename lockable_type<Locker>::type lockable_type; typedef typename syntactic_lock_traits<lockable_type>::lock_error lock_error; nested_strict_lock(Locker& lock) : lock_(lock) // Store reference to locker , tmp_lock_(lock.move()) // Move ownership to temporaty locker { #ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED if (tmp_lock_.mutex()==0) { lock_=tmp_lock_.move(); // Rollback for coherency purposes throw lock_error(); } #endif if (!tmp_lock_) tmp_lock_.lock(); // ensures it is locked } ~nested_strict_lock() { lock_=tmp_lock_.move(); // Move ownership to nesting locker } bool owns_lock() const { return true; } lockable_type* mutex() const { return tmp_lock_.mutex(); } bool owns_lock(lockable_type* l) const { return l==mutex(); } private: Locker& lock_; Locker tmp_lock_; };
The externally_locked
get function is now a template function taking a Locker as parameters
instead of a strict_lock
.
We can add test in debug mode that ensure that the Lockable object is
locked.
template <typename T, typename Lockable> class externally_locked { public: // ... template <class Locker> T& get(Locker& lock) { BOOST_CONCEPT_ASSERT((StrictLockerConcept<Locker>)); BOOST_STATIC_ASSERT((is_strict_lock<Locker>::value)); // locker is a strict locker "sur parole" BOOST_STATIC_ASSERT((is_same<Lockable, typename lockable_type<Locker>::type>::value)); // that locks the same type #ifndef BOOST_THREAD_EXTERNALLY_LOCKED_DONT_CHECK_OWNERSHIP // define BOOST_THREAD_EXTERNALLY_LOCKED_NO_CHECK_OWNERSHIP if you don't want to check locker ownership if (! lock ) throw lock_error(); // run time check throw if no locked #endif #ifdef BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED if (!lock.owns_lock(&lockable_)) throw lock_error(); #endif return obj_; } };
The AccountManager::AMoreComplicatedFunction
function needs
only to replace the strict_lock
by a nested_strict_lock
.
void AccountManager::AMoreComplicatedChecking2Savings(int amount) { unique_lock<AccountManager> guard1(*this); if (some_condition()) { guard1.lock(); } { nested_strict_lock<unique_lock<AccountManager> > guard(guard1); checkingAcct_.get(guard).Withdraw(amount); savingsAcct_.get(guard).Deposit(amount); } guard1.unlock(); }
In particular, the library provides a way to lock around the execution of a function.
template <class Lockable, class Function, class... Args> auto with_lock_guard( Lockable& m, Function&& func, Args&&... args ) -> decltype(func(boost::forward<Args>(args)...)) { boost::lock_guard<Lockable> lock(m); return func(boost::forward<Args>(args)...); }
that can be used with regular functions:
int func(int, int&); //... boost::mutex m; int a; int result = boost::with_lock_guard(m, func, 1, boost::ref(a));
with boost::bind:
int result = boost::with_lock_guard( m, boost::bind(func, 2, boost::ref(a)) );
or with lambda expression:
int a; int result = boost::with_lock_guard( m, [&a](int x) { // this scope is protected by mutex m a = 3; return x + 4; }, 5 );
A mutex object facilitates protection against data races and allows thread-safe synchronization of data between threads. A thread obtains ownership of a mutex object by calling one of the lock functions and relinquishes ownership by calling the corresponding unlock function. Mutexes may be either recursive or non-recursive, and may grant simultaneous ownership to one or many threads. Boost.Thread supplies recursive and non-recursive mutexes with exclusive ownership semantics, along with a shared ownership (multiple-reader / single-writer) mutex.
Boost.Thread supports four basic concepts
for lockable objects: Lockable
, TimedLockable
, SharedLockable
and UpgradeLockable
. Each mutex type
implements one or more of these concepts, as do the various lock types.
// #include <boost/thread/lockable_concepts.hpp> namespace boost { template<typename L> class BasicLockable; // EXTENSION }
The BasicLockable
concept models exclusive
ownership. A type L
meets
the BasicLockable
requirements if
the following expressions are well-formed and have the specified semantics
(m
denotes a value of type
L
):
Lock ownership acquired through a call to lock()
must be released through a call to unlock()
.
The calling thread doesn't owns the mutex if the mutex is not recursive.
The current thread blocks until ownership can be obtained for the current thread.
Prior unlock()
operations on the same object synchronizes with this operation.
The current thread owns m
.
void
.
lock_error
if an
error occurs.
operation_not_permitted: if the thread does not have the privilege to perform the operation.
resource_deadlock_would_occur: if the implementation detects that a deadlock would occur.
device_or_resource_busy: if the mutex is already locked and blocking is not possible.
If an exception is thrown then a lock shall not have been acquired for the current thread.
The current thread owns m
.
This operation synchronizes with subsequent lock operations that obtain ownership on the same object.
Releases a lock on m
by the current thread.
void
.
Nothing.
// #include <boost/thread/lockable_traits.hpp> namespace boost { namespace sync { template<typename L> class is_basic_lockable;// EXTENSION } }
Some of the algorithms on mutexes use this trait via SFINAE.
This trait is true_type if the parameter L meets the Lockable
requirements.
Warning | |
---|---|
If BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES is defined you will need to specialize this traits for the models of BasicLockable you could build. |
// #include <boost/thread/lockable_concepts.hpp> namespace boost { template<typename L> class Lockable; }
A type L
meets the Lockable
requirements if it meets
the BasicLockable
requirements and
the following expressions are well-formed and have the specified semantics
(m
denotes a value of type
L
):
m.try_lock
()
Lock ownership acquired through a call to try_lock()
must be released through a call to unlock()
.
The calling thread doesn't owns the mutex if the mutex is not recursive.
Attempt to obtain ownership for the current thread without blocking.
If try_lock()
returns true, prior unlock()
operations on the same object
synchronize with this operation.
Since lock()
does not synchronize with a failed subsequent try_lock()
, the visibility rules are weak
enough that little would be known about the state after a failure,
even in the absence of spurious failures.
bool
.
true
if ownership
was obtained for the current thread, false
otherwise.
If the call returns true
,
the current thread owns the m
.
Nothing.
// #include <boost/thread/lockable_traits.hpp> namespace boost { namespace sync { template<typename L> class is_lockable;// EXTENSION } }
Some of the algorithms on mutexes use this trait via SFINAE.
This trait is true_type if the parameter L meets the Lockable
requirements.
Warning | |
---|---|
If BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES is defined you will need to specialize this traits for the models of Lockable you could build. |
The user could require that the mutex passed to an algorithm is a recursive one. Whether a lockable is recursive or not can not be checked using template meta-programming. This is the motivation for the following trait.
// #include <boost/thread/lockable_traits.hpp> namespace boost { namespace sync { template<typename L> class is_recursive_mutex_sur_parole: false_type; // EXTENSION template<> class is_recursive_mutex_sur_parole<recursive_mutex>: true_type; // EXTENSION template<> class is_recursive_mutex_sur_parole<timed_recursive_mutex>: true_type; // EXTENSION } }
The trait is_recursive_mutex_sur_parole
is false_type
by default
and is specialized for the provide recursive_mutex
and timed_recursive_mutex
.
It should be specialized by the user providing other model of recursive lockable.
// #include <boost/thread/lockable_traits.hpp> namespace boost { namespace sync { template<typename L> class is_recursive_basic_lockable;// EXTENSION } }
This traits is true_type if is_basic_lockable and is_recursive_mutex_sur_parole.
// #include <boost/thread/lockable_traits.hpp> namespace boost { namespace sync { template<typename L> class is_recursive_lockable;// EXTENSION } }
This traits is true_type if is_lockable and is_recursive_mutex_sur_parole.
// #include <boost/thread/lockable_concepts.hpp> namespace boost { template<typename L> class TimedLockable; // EXTENSION }
The TimedLockable
concept refines
the Lockable
concept to add support
for timeouts when trying to acquire the lock.
A type L
meets the TimedLockable
requirements if
it meets the Lockable
requirements and the
following expressions are well-formed and have the specified semantics.
Variables:
m
denotes a value of
type L
,
rel_time
denotes a
value of an instantiation of chrono::duration
,
and
abs_time
denotes a
value of an instantiation of chrono::time_point
:
Expressions:
m.try_lock_for
(rel_time)
m.try_lock_until
(abs_time)
Lock ownership acquired through a call to try_lock_for
or try_lock_until
must be released
through a call to unlock
.
The calling thread doesn't owns the mutex if the mutex is not recursive.
Attempt to obtain ownership for the current thread. Blocks until
ownership can be obtained, or the specified time is reached. If
the specified time has already passed, behaves as try_lock()
.
If try_lock_until()
returns true, prior unlock()
operations on the same object synchronize with this operation.
bool
.
true
if ownership
was obtained for the current thread, false
otherwise.
If the call returns true
,
the current thread owns m
.
Nothing.
The calling thread doesn't owns the mutex if the mutex is not recursive.
As-if
.
try_lock_until
(chrono::steady_clock::now() + rel_time)
If try_lock_for()
returns true, prior unlock()
operations on the same object synchronize with this operation.
Warning | |
---|---|
DEPRECATED since 4.00. The following expressions were required on version 2, but are now deprecated.
Use instead |
Variables:
rel_time
denotes a
value of an instantiation of an unspecified DurationType
arithmetic compatible with boost::system_time
,
and
abs_time
denotes a
value of an instantiation of boost::system_time
:
Expressions:
m.timed_lock
(rel_time)
m.timed_lock
(abs_time)
Lock ownership acquired through a call to timed_lock()
must be released through a call to unlock()
.
Attempt to obtain ownership for the current thread. Blocks until
ownership can be obtained, or the specified time is reached. If
the specified time has already passed, behaves as try_lock()
.
true
if ownership
was obtained for the current thread, false
otherwise.
If the call returns true
,
the current thread owns m
.
lock_error
if an
error occurs.
// #include <boost/thread/lockable_concepts.hpp> namespace boost { template<typename L> class SharedLockable; // C++14 }
The SharedLockable
concept is a refinement
of the TimedLockable
concept that allows
for shared ownership as well as exclusive
ownership. This is the standard multiple-reader / single-write
model: at most one thread can have exclusive ownership, and if any thread
does have exclusive ownership, no other threads can have shared or exclusive
ownership. Alternatively, many threads may have shared ownership.
A type L
meets the SharedLockable
requirements if
it meets the TimedLockable
requirements and
the following expressions are well-formed and have the specified semantics.
Variables:
m
denotes a value of
type L
,
rel_time
denotes a
value of an instantiation of chrono::duration
,
and
abs_time
denotes a
value of an instantiation of chrono::time_point
:
Expressions:
m.lock_shared()
();
m.try_lock_shared
()
m.try_lock_shared_for
(rel_time)
m.try_lock_shared_until
(abs_time)
m.unlock_shared()
();
Lock ownership acquired through a call to lock_shared()
,
try_lock_shared()
,
try_lock_shared_for
or try_lock_shared_until
must be
released through a call to unlock_shared()
.
The current thread blocks until shared ownership can be obtained for the current thread.
The current thread has shared ownership of m
.
lock_error
if an
error occurs.
Attempt to obtain shared ownership for the current thread without blocking.
true
if shared ownership
was obtained for the current thread, false
otherwise.
If the call returns true
,
the current thread has shared ownership of m
.
lock_error
if an
error occurs.
Attempt to obtain shared ownership for the current thread. Blocks
until shared ownership can be obtained, or the specified duration
is elapsed. If the specified duration is already elapsed, behaves
as try_lock_shared()
.
true
if shared ownership
was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has shared ownership of m
.
lock_error
if an
error occurs.
Attempt to obtain shared ownership for the current thread. Blocks
until shared ownership can be obtained, or the specified time is
reached. If the specified time has already passed, behaves as
try_lock_shared()
.
true
if shared ownership
was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has shared ownership of m
.
lock_error
if an
error occurs.
The current thread has shared ownership of m
.
Releases shared ownership of m
by the current thread.
The current thread no longer has shared ownership of m
.
Nothing
Warning | |
---|---|
DEPRECATED since 3.00. The following expressions were required on version 2, but are now deprecated.
Use instead |
Variables:
abs_time
denotes a
value of an instantiation of boost::system_time
:
Expressions:
m.timed_lock_shared(abs_time);
Lock ownership acquired through a call to timed_lock_shared()
must be released through a call to unlock_shared()
.
Attempt to obtain shared ownership for the current thread. Blocks
until shared ownership can be obtained, or the specified time is
reached. If the specified time has already passed, behaves as
try_lock_shared()
.
true
if shared ownership
was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has shared ownership of m
.
lock_error
if an
error occurs.
m.lock_upgrade()
m.unlock_upgrade()
m.try_lock_upgrade()
m.try_lock_upgrade_for(rel_time)
m.try_lock_upgrade_until(abs_time)
m.try_unlock_shared_and_lock()
m.try_unlock_shared_and_lock_for(rel_time)
m.try_unlock_shared_and_lock_until(abs_time)
m.unlock_and_lock_shared()
m.try_unlock_shared_and_lock_upgrade()
m.try_unlock_shared_and_lock_upgrade_for(rel_time)
m.try_unlock_shared_and_lock_upgrade_until(abs_time)
m.unlock_and_lock_upgrade()
m.unlock_upgrade_and_lock()
m.try_unlock_upgrade_and_lock()
m.try_unlock_upgrade_and_lock_for(rel_time)
m.try_unlock_upgrade_and_lock_until(abs_time)
m.unlock_upgrade_and_lock_shared()
// #include <boost/thread/lockable_concepts.hpp> namespace boost { template<typename L> class UpgradeLockable; // EXTENSION }
The UpgradeLockable
concept is a refinement
of the SharedLockable
concept that allows
for upgradable ownership as well as shared
ownership and exclusive ownership. This
is an extension to the multiple-reader / single-write model provided by
the SharedLockable
concept: a single
thread may have upgradable ownership at the same time
as others have shared ownership. The thread with
upgradable ownership may at any time attempt to upgrade
that ownership to exclusive ownership. If no other
threads have shared ownership, the upgrade is completed immediately, and
the thread now has exclusive ownership, which must
be relinquished by a call to unlock()
,
just as if it had been acquired by a call to lock()
.
If a thread with upgradable ownership tries to upgrade whilst other threads have shared ownership, the attempt will fail and the thread will block until exclusive ownership can be acquired.
Ownership can also be downgraded as well as upgraded:
exclusive ownership of an implementation of the UpgradeLockable
concept can be
downgraded to upgradable ownership or shared ownership, and upgradable
ownership can be downgraded to plain shared ownership.
A type L
meets the UpgradeLockable
requirements if
it meets the SharedLockable
requirements and
the following expressions are well-formed and have the specified semantics.
Variables:
m
denotes a value of
type L
,
rel_time
denotes a
value of an instantiation of chrono::duration
,
and
abs_time
denotes a
value of an instantiation of chrono::time_point
:
Expressions:
m.lock_upgrade
();
m.unlock_upgrade
()
m.try_lock_upgrade
()
m.try_lock_upgrade_for
(rel_time)
m.try_lock_upgrade_until
(abs_time)
m.unlock_and_lock_shared
()
m.unlock_and_lock_upgrade
();
m.unlock_upgrade_and_lock
();
m.try_unlock_upgrade_and_lock
()
m.try_unlock_upgrade_and_lock_for
(rel_time)
m.try_unlock_upgrade_and_lock_until
(abs_time)
m.unlock_upgrade_and_lock_shared
();
If `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION is defined the following expressions are also required:
m.try_unlock_shared_and_lock
();
m.try_unlock_shared_and_lock_for
(rel_time);
m.try_unlock_shared_and_lock_until
(abs_time);
m.try_unlock_shared_and_lock_upgrade
();
m.try_unlock_shared_and_lock_upgrade_for
(rel_time);
m.try_unlock_shared_and_lock_upgrade_until
(abs_time);
Lock ownership acquired through a call to lock_upgrade()
must be released through a call to unlock_upgrade()
.
If the ownership type is changed through a call to one of the unlock_xxx_and_lock_yyy()
functions, ownership must be released through a call to the unlock function
corresponding to the new level of ownership.
The calling thread has no ownership of the mutex.
The current thread blocks until upgrade ownership can be obtained for the current thread.
The current thread has upgrade ownership of m
.
Prior
operations on the same object
synchronize with this operation.
unlock_upgrade
()
lock_error
if an
error occurs.
The current thread has upgrade ownership of m
.
Releases upgrade ownership of m
by the current thread.
The current thread no longer has upgrade ownership of m
.
This operation synchronizes with subsequent lock operations that obtain ownership on the same object.
Nothing
The calling thread has no ownership of the mutex.
Attempts to obtain upgrade ownership of the mutex for the calling thread without blocking. If upgrade ownership is not obtained, there is no effect and try_lock_upgrade() immediately returns.
true
if upgrade ownership
was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has upgrade ownership of m
.
If
returns true, prior try_lock_upgrade
()
operations on the same object
synchronize with this operation.
unlock_upgrade
()
Nothing
The calling thread has no ownership of the mutex.
If the tick period of rel_time
is not exactly convertible to the native tick period, the duration
shall be rounded up to the nearest native tick period. Attempts
to obtain upgrade lock ownership for the calling thread within
the relative timeout specified by rel_time
.
If the time specified by rel_time
is less than or equal to rel_time.zero()
, the function attempts to obtain
ownership without blocking (as if by calling
). The function returns within
the timeout specified by try_lock_upgrade
()rel_time
only if it has obtained upgrade ownership of the mutex object.
true
if upgrade ownership
was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has upgrade ownership of m
.
If
returns true, prior try_lock_upgrade_for
(rel_time)
operations on the same object
synchronize with this operation.
unlock_upgrade
()
Nothing
Available only if BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The calling thread has no ownership of the mutex.
The function attempts to obtain upgrade ownership of the mutex.
If abs_time
has
already passed, the function attempts to obtain upgrade ownership
without blocking (as if by calling
). The function returns before
the absolute timeout specified by try_lock_upgrade
()abs_time
only if it has obtained upgrade ownership of the mutex object.
true
if upgrade ownership
was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has upgrade ownership of m
.
If
returns true, prior try_lock_upgrade_until
(abs_time)
operations on the same object
synchronize with this operation.
unlock_upgrade
()
Nothing
Available only if BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The calling thread must hold a shared lock on the mutex.
The function attempts to atomically convert the ownership from shared to exclusive for the calling thread without blocking. For this conversion to be successful, this thread must be the only thread holding any ownership of the lock. If the conversion is not successful, the shared ownership of m is retained.
true
if exclusive
ownership was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has exclusive ownership of m
.
If
returns true, prior try_unlock_shared_and_lock
()
and subsequent lock operations on the same object synchronize with
this operation.
unlock
()
Nothing
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The calling thread shall hold a shared lock on the mutex.
If the tick period of rel_time
is not exactly convertible to the native tick period, the duration
shall be rounded up to the nearest native tick period. The function
attempts to atomically convert the ownership from shared to exclusive
for the calling thread within the relative timeout specified by
rel_time
. If the
time specified by rel_time
is less than or equal to rel_time.zero()
, the function attempts to obtain
exclusive ownership without blocking (as if by calling try_unlock_shared_and_lock()
).
The function shall return within the timeout specified by rel_time
only if it has obtained
exclusive ownership of the mutex object. For this conversion to
be successful, this thread must be the only thread holding any
ownership of the lock at the moment of conversion. If the conversion
is not successful, the shared ownership of the mutex is retained.
true
if exclusive
ownership was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has exclusive ownership of m
.
If
returns true, prior try_unlock_shared_and_lock_for
(rel_time)
and subsequent lock operations on the same object synchronize with
this operation.
unlock
()
Nothing
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The calling thread shall hold a shared lock on the mutex.
The function attempts to atomically convert the ownership from
shared to exclusive for the calling thread within the absolute
timeout specified by abs_time
.
If abs_time
has
already passed, the function attempts to obtain exclusive ownership
without blocking (as if by calling try_unlock_shared_and_lock()
). The function shall return before
the absolute timeout specified by abs_time
only if it has obtained exclusive ownership of the mutex object.
For this conversion to be successful, this thread must be the only
thread holding any ownership of the lock at the moment of conversion.
If the conversion is not successful, the shared ownership of the
mutex is retained.
true
if exclusive
ownership was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has exclusive ownership of m
.
If
returns true, prior try_unlock_shared_and_lock_until
(rel_time)
and subsequent lock operations on the same object synchronize with
this operation.
unlock
()
Nothing
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The calling thread shall hold an exclusive lock on m
.
Atomically converts the ownership from exclusive to shared for the calling thread.
The current thread has shared ownership of m
.
This operation synchronizes with subsequent lock operations that obtain ownership of the same object.
Nothing
The calling thread shall hold a shared lock on the mutex.
The function attempts to atomically convert the ownership from shared to upgrade for the calling thread without blocking. For this conversion to be successful, there must be no thread holding upgrade ownership of this object. If the conversion is not successful, the shared ownership of the mutex is retained.
true
if upgrade ownership
was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has upgrade ownership of m
.
If
returns true, prior try_unlock_shared_and_lock_upgrade
()
and subsequent lock operations
on the same object synchronize with this operation.
unlock_upgrade
()
Nothing
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The calling thread shall hold a shared lock on the mutex.
If the tick period of rel_time
is not exactly convertible to the native tick period, the duration
shall be rounded up to the nearest native tick period. The function
attempts to atomically convert the ownership from shared to upgrade
for the calling thread within the relative timeout specified by
rel_time
. If the
time specified by rel_time
is less than or equal to rel_time.zero()
, the function attempts to obtain
upgrade ownership without blocking (as if by calling
). The function shall return within
the timeout specified by try_unlock_shared_and_lock_upgrade
()rel_time
only if it has obtained exclusive ownership of the mutex object.
For this conversion to be successful, there must be no thread holding
upgrade ownership of this object at the moment of conversion. If
the conversion is not successful, the shared ownership of m is
retained.
true
if upgrade ownership
was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has upgrade ownership of m
.
If
returns true, prior try_unlock_shared_and_lock_upgrade_for
(rel_time)
and subsequent lock operations
on the same object synchronize with this operation.
unlock_upgrade
()
Nothing
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The calling thread shall hold a shared lock on the mutex.
The function attempts to atomically convert the ownership from
shared to upgrade for the calling thread within the absolute timeout
specified by abs_time
.
If abs_time
has
already passed, the function attempts to obtain upgrade ownership
without blocking (as if by calling
). The function shall return before
the absolute timeout specified by try_unlock_shared_and_lock_upgrade
()abs_time
only if it has obtained upgrade ownership of the mutex object.
For this conversion to be successful, there must be no thread holding
upgrade ownership of this object at the moment of conversion. If
the conversion is not successful, the shared ownership of the mutex
is retained.
true
if upgrade ownership
was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has upgrade ownership of m
.
If
returns true, prior try_unlock_shared_and_lock_upgrade_until
(rel_time)
and subsequent lock operations
on the same object synchronize with this operation.
unlock_upgrade
()
Nothing
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The current thread has exclusive ownership of m
.
Atomically releases exclusive ownership of m
by the current thread and acquires upgrade ownership of m
without blocking.
The current thread has upgrade ownership of m
.
This operation synchronizes with subsequent lock operations that obtain ownership of the same object.
Nothing
The current thread has upgrade ownership of m
.
Atomically releases upgrade ownership of m
by the current thread and acquires exclusive ownership of m
. If any other threads have
shared ownership, blocks until exclusive ownership can be acquired.
The current thread has exclusive ownership of m
.
This operation synchronizes with prior
and subsequent lock operations
that obtain ownership of the same object.
unlock_shared()
()
Nothing
The calling thread shall hold a upgrade lock on the mutex.
The function attempts to atomically convert the ownership from upgrade to exclusive for the calling thread without blocking. For this conversion to be successful, this thread must be the only thread holding any ownership of the lock. If the conversion is not successful, the upgrade ownership of m is retained.
true
if exclusive
ownership was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has exclusive ownership of m
.
If
returns true, prior try_unlock_upgrade_and_lock
()
and subsequent lock operations on the same object synchronize with
this operation.
unlock
()
Nothing
Available only if BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The calling thread shall hold a upgrade lock on the mutex.
If the tick period of rel_time
is not exactly convertible to the native tick period, the duration
shall be rounded up to the nearest native tick period. The function
attempts to atomically convert the ownership from upgrade to exclusive
for the calling thread within the relative timeout specified by
rel_time
. If the
time specified by rel_time
is less than or equal to rel_time.zero()
, the function attempts to obtain
exclusive ownership without blocking (as if by calling
). The function shall return within
the timeout specified by try_unlock_upgrade_and_lock
()rel_time
only if it has obtained exclusive ownership of the mutex object.
For this conversion to be successful, this thread shall be the
only thread holding any ownership of the lock at the moment of
conversion. If the conversion is not successful, the upgrade ownership
of m is retained.
true
if exclusive
ownership was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has exclusive ownership of m
.
If
returns true, prior try_unlock_upgrade_and_lock_for
(rel_time)
and subsequent lock operations on the same object synchronize with
this operation.
unlock
()
Nothing
Available only if BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The calling thread shall hold a upgrade lock on the mutex.
The function attempts to atomically convert the ownership from
upgrade to exclusive for the calling thread within the absolute
timeout specified by abs_time
.
If abs_time
has
already passed, the function attempts to obtain exclusive ownership
without blocking (as if by calling
). The function shall return before
the absolute timeout specified by try_unlock_upgrade_and_lock
()abs_time
only if it has obtained exclusive ownership of the mutex object.
For this conversion to be successful, this thread shall be the
only thread holding any ownership of the lock at the moment of
conversion. If the conversion is not successful, the upgrade ownership
of m is retained.
true
if exclusive
ownership was acquired for the current thread, false
otherwise.
If the call returns true
,
the current thread has exclusive ownership of m
.
If
returns true, prior try_unlock_upgrade_and_lock_for
(rel_time)
and subsequent lock operations on the same object synchronize with
this operation.
unlock
()
Nothing
Available only if BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
The current thread has upgrade ownership of m
.
Atomically releases upgrade ownership of m
by the current thread and acquires shared ownership of m
without blocking.
The current thread has shared ownership of m
.
This operation synchronizes with prior unlock_shared()
and subsequent lock operations
that obtain ownership of the same object.
Nothing
// #include <boost/thread/locks.hpp> // #include <boost/thread/locks_options.hpp> namespace boost { struct defer_lock_t {}; struct try_to_lock_t {}; struct adopt_lock_t {}; constexpr defer_lock_t defer_lock; constexpr try_to_lock_t try_to_lock; constexpr adopt_lock_t adopt_lock;
#include <boost/thread/locks.hpp> #include <boost/thread/locks_options.hpp> struct defer_lock_t {}; struct try_to_lock_t {}; struct adopt_lock_t {}; const defer_lock_t defer_lock; const try_to_lock_t try_to_lock; const adopt_lock_t adopt_lock;
These tags are used in scoped locks constructors to specify a specific behavior.
defer_lock_t
: is used
to construct the scoped lock without locking it.
try_to_lock_t
: is used
to construct the scoped lock trying to lock it.
adopt_lock_t
: is used
to construct the scoped lock without locking it but adopting ownership.
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_guard.hpp> namespace boost { template<typename Lockable> class lock_guard #if ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD template <typename Lockable> lock_guard<Lockable> make_lock_guard(Lockable& mtx); // EXTENSION template <typename Lockable> lock_guard<Lockable> make_lock_guard(Lockable& mtx, adopt_lock_t); // EXTENSION #endif }
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_guard.hpp> template<typename Lockable> class lock_guard { public: explicit lock_guard(Lockable& m_); lock_guard(Lockable& m_,boost::adopt_lock_t); ~lock_guard(); };
boost::lock_guard
is very simple: on
construction it acquires ownership of the implementation of the Lockable
concept supplied as the
constructor parameter. On destruction, the ownership is released. This
provides simple RAII-style locking of a Lockable
object, to facilitate
exception-safe locking and unlocking. In addition, the lock_guard(Lockable &
m,boost::adopt_lock_t)
constructor allows the boost::lock_guard
object to take ownership
of a lock already held by the current thread.
The current thread owns a lock on m
equivalent to one obtained by a call to m.lock()
.
Stores a reference to m
.
Takes ownership of the lock state of m
.
Nothing.
Invokes m.unlock()
on the Lockable
object passed
to the constructor.
Nothing.
template <typename Lockable> lock_guard<Lockable> make_lock_guard(Lockable& m); // EXTENSION
a lock_guard as if initialized with {m}
.
Any exception thrown by the call to m.lock()
.
template <typename Lockable> lock_guard<Lockable> make_lock_guard(Lockable& m, adopt_lock_t); // EXTENSION
a lock_guard as if initialized with {m, adopt_lock}
.
Any exception thrown by the call to m.lock()
.
// #include <boost/thread/with_lock_guard.hpp> namespace boost { template <class Lockable, class Function, class... Args> auto with_lock_guard(Lockable& m, Function&& func, Args&&... args) -> decltype(func(boost::forward<Args>(args)...)); }
template <class Lockable, class Function, class... Args> auto with_lock_guard( Lockable& m, Function&& func, Args&&... args ) -> decltype(func(boost::forward<Args>(args)...));
m
must be in unlocked
state
call func
in scope
locked by m
Result of func(args...)
call
Any exception thrown by the call to m.lock
and func(args...)
m
is in unlocked
state
Without c++11 variadic templates support number of arguments is limited
to 4
Without rvalue references support calling class method with boost::bind
must be const
For correct work with lambda macro BOOST_RESULT_OF_USE_DECLTYPE
may be needed to define
// #include <boost/thread/lock_concepts.hpp> namespace boost { template<typename Lock> class StrictLock; }
A StrictLock is a lock that ensures that the associated mutex is locked during the lifetime of the lock.
A type L
meets the StrictLock
requirements if the following expressions are well-formed and have the
specified semantics
L::mutex_type
is_strict_lock<L>
cl.owns_lock(m);
and BasicLockable<L::mutex_type>
where
cl
denotes a value
of type L const&
,
m
denotes a value of
type L::mutex_type const*
,
The type L::mutex_type denotes the mutex that is locked by this lock.
As the semantic "ensures that the associated mutex is locked during
the lifetime of the lock. " can not be described by syntactic requirements
a is_strict_lock_sur_parole
trait must be specialized by the user defining the lock so that the following
assertion is true:
is_strict_lock_sur_parole<L>::value == true
bool
Whether the strict lock is locking the mutex m
Nothing.
The following classes are models of StrictLock
:
boost::lock_guard
: "sur parole"
as the user could use adopt_lock_t constructor overload without having
locked the mutex.
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> namespace boost { template<typename Lockable> class unique_lock; template<typename Mutex> void swap(unique_lock <Mutex>& lhs, unique_lock <Mutex>& rhs); template<typename Lockable> class shared_lock; // C++14 template<typename Mutex> void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs); // C++14 template<typename Lockable> class upgrade_lock; // EXTENSION template<typename Mutex> void swap(upgrade_lock <Mutex>& lhs, upgrade_lock <Mutex>& rhs); // EXTENSION template <class Mutex> class upgrade_to_unique_lock; // EXTENSION }
unique_lock()
unique_lock(Lockable &
m)
unique_lock(Lockable &
m,boost::adopt_lock_t)
unique_lock(Lockable &
m,boost::defer_lock_t)
unique_lock(Lockable &
m,boost::try_to_lock_t)
unique_lock(shared_lock<mutex_type>&&
sl,
try_to_lock_t)
unique_lock(shared_lock<mutex_type>&&,
const chrono::time_point<Clock, Duration>&)
unique_lock(shared_lock<mutex_type>&&,
const chrono::duration<Rep, Period>&)
unique_lock(Lockable &
m,boost::system_time const& abs_time)
template <class Clock, class Duration>
unique_lock(Lockable &
m,const chrono::time_point<Clock, Duration>& abs_time)
template <class Rep, class Period>
unique_lock(Lockable &
m,const chrono::duration<Rep, Period>& abs_time)
~unique_lock()
bool owns_lock() const
Lockable* mutex() const noexcept
explicit operator
bool()
const
Lockable* release()
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> template<typename Lockable> class unique_lock { public: typedef Lockable mutex_type; unique_lock() noexcept; explicit unique_lock(Lockable& m_); unique_lock(Lockable& m_,adopt_lock_t); unique_lock(Lockable& m_,defer_lock_t) noexcept; unique_lock(Lockable& m_,try_to_lock_t); #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION unique_lock(shared_lock<mutex_type>&& sl, try_to_lock_t); // C++14 template <class Clock, class Duration> unique_lock(shared_lock<mutex_type>&& sl, const chrono::time_point<Clock, Duration>& abs_time); // C++14 template <class Rep, class Period> unique_lock(shared_lock<mutex_type>&& sl, const chrono::duration<Rep, Period>& rel_time); // C++14 #endif template <class Clock, class Duration> unique_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t); template <class Rep, class Period> unique_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d); ~unique_lock(); unique_lock(unique_lock const&) = delete; unique_lock& operator=(unique_lock const&) = delete; unique_lock(unique_lock<Lockable>&& other) noexcept; explicit unique_lock(upgrade_lock<Lockable>&& other) noexcept; // EXTENSION unique_lock& operator=(unique_lock<Lockable>&& other) noexcept; void swap(unique_lock& other) noexcept; Lockable* release() noexcept; void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); explicit operator bool() const noexcept; bool owns_lock() const noexcept; mutex_type* mutex() const noexcept; #if defined BOOST_THREAD_USE_DATE_TIME || defined BOOST_THREAD_DONT_USE_CHRONO unique_lock(Lockable& m_,system_time const& target_time); template<typename TimeDuration> bool timed_lock(TimeDuration const& relative_time); bool timed_lock(::boost::system_time const& absolute_time); #endif };
boost::unique_lock
is more complex than
boost::lock_guard
: not only does it provide
for RAII-style locking, it also allows for deferring acquiring the lock
until the lock()
member function is called explicitly, or trying to acquire the lock in
a non-blocking fashion, or with a timeout. Consequently, unlock()
is only called in the destructor if the lock object has locked the Lockable
object, or otherwise
adopted a lock on the Lockable
object.
Specializations of boost::unique_lock
model the TimedLockable
concept if the supplied
Lockable
type itself models
TimedLockable
concept (e.g. boost::unique_lock<boost::timed_mutex>
),
or the Lockable
concept if the supplied
Lockable
type itself models
Lockable
concept (e.g. boost::unique_lock<boost::mutex>
),
or the BasicLockable
concept if the supplied
Lockable
type itself models
BasicLockable
concept.
An instance of boost::unique_lock
is said to own
the lock state of a Lockable
m
if mutex()
returns a pointer to m
and owns_lock()
returns true
. If an object
that owns the lock state of a Lockable
object is destroyed,
then the destructor will invoke mutex()->unlock()
.
The member functions of boost::unique_lock
are not thread-safe.
In particular, boost::unique_lock
is intended to model
the ownership of a Lockable
object by a particular
thread, and the member functions that release ownership of the lock state
(including the destructor) must be called by the same thread that acquired
ownership of the lock state.
Creates a lock object with no associated mutex.
owns_lock()
returns false
. mutex()
returns NULL
.
Nothing.
Stores a reference to m
.
Invokes m.lock()
.
owns_lock()
returns true
. mutex()
returns &m
.
Any exception thrown by the call to m.lock()
.
The current thread owns an exclusive lock on m
.
Stores a reference to m
.
Takes ownership of the lock state of m
.
owns_lock()
returns true
. mutex()
returns &m
.
Nothing.
Stores a reference to m
.
owns_lock()
returns false
. mutex()
returns &m
.
Nothing.
Stores a reference to m
.
Invokes m.try_lock()
,
and takes ownership of the lock state if the call returns true
.
mutex()
returns &m
.
If the call to try_lock()
returned true
, then
owns_lock()
returns true
, otherwise
owns_lock()
returns false
.
Nothing.
The supplied Mutex
type must implement
.
try_unlock_shared_and_lock
()
Constructs an object of type boost::unique_lock
. Let pm
be the pointer to the mutex
and owns
the ownership
state. Initializes pm
with nullptr and owns
with false. If sl.
returns owns_lock()
()false
,
sets pm
to the
return value of sl.release()
. Else sl.
returns owns_lock()
()true
,
and in this case if sl.mutex()->try_unlock_shared_and_lock()
returns true
,
sets pm
to the
value returned by sl.release()
and sets owns
to true
.
If sl.owns_lock()
returns true
and
sl.mutex()->try_unlock_shared_and_lock()
returns false
, sl
is not modified.
Nothing.
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
template <class Clock, class Duration> unique_lock(shared_lock<mutex_type>&& sl, const chrono::time_point<Clock, Duration>& abs_time);
The supplied Mutex
type shall implement
.
try_unlock_shared_and_lock_until
(abs_time)
Constructs an object of type
, initializing
boost::unique_lock
pm
with nullptr
and owns
with false
. If sl.
returns owns_lock()
()false
,
sets pm
to the
return value of sl.release()
. Else sl.
returns owns_lock()
()true
,
and in this case if sl.mutex()->
returns try_unlock_shared_and_lock_until
(abs_time)true
,
sets pm
to the
value returned by sl.release()
and sets owns
to true
.
If sl.owns_lock()
returns true
and
sl.mutex()->
returns try_unlock_shared_and_lock_until
(abs_time)false
,
sl
is not modified.
Nothing.
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
template <class Rep, class Period> unique_lock(shared_lock<mutex_type>&& sl, const chrono::duration<Rep, Period>& rel_time)
The supplied Mutex
type shall implement
.
try_unlock_shared_and_lock_for
(rel_time)
Constructs an object of type
, initializing
boost::unique_lock
pm
with nullptr
and owns
with false
. If sl.
returns owns_lock()
()false
,
sets pm
to the
return value of sl.release()
. Else sl.owns_lock()
returns true
,
and in this case if sl.mutex()->
returns try_unlock_shared_and_lock_for
(rel_time)true
,
sets pm
to the
value returned by sl.release()
and sets owns
to true
.
If sl.owns_lock()
returns true
and
sl.mutex()->
returns try_unlock_shared_and_lock_for
(rel_time)false
,
sl
is not modified.
.
Nothing.
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
Stores a reference to m
.
Invokes m.timed_lock(abs_time)
,
and takes ownership of the lock state if the call returns true
.
mutex()
returns &m
.
If the call to timed_lock()
returned true
, then
owns_lock()
returns true
, otherwise
owns_lock()
returns false
.
Any exceptions thrown by the call to m.timed_lock(abs_time)
.
Stores a reference to m
.
Invokes m.
, and takes ownership of the lock
state if the call returns try_lock_until
(abs_time)true
.
mutex()
returns &m
.
If the call to try_lock_until
returned
true
, then owns_lock()
returns true
, otherwise
owns_lock()
returns false
.
Any exceptions thrown by the call to m.
.
try_lock_until
(abs_time)
Stores a reference to m
.
Invokes m.
,
and takes ownership of the lock state if the call returns try_lock_for
(rel_time)true
.
mutex()
returns &m
.
If the call to try_lock_for
returned
true
, then owns_lock()
returns true
, otherwise
owns_lock()
returns false
.
Any exceptions thrown by the call to m.
.
try_lock_for
(rel_time)
Invokes mutex()
->
unlock()
if owns_lock()
returns true
.
Nothing.
true
if the *this
owns the lock on the Lockable
object associated
with *this
.
Nothing.
A pointer to the Lockable
object associated
with *this
,
or NULL
if there
is no such object.
Nothing.
.
owns_lock()
()
Nothing.
The association between *this
and the Lockable
object is removed,
without affecting the lock state of the Lockable
object. If owns_lock()
would have returned true
,
it is the responsibility of the calling code to ensure that the
Lockable
is correctly
unlocked.
A pointer to the Lockable
object associated
with *this
at the point of the call, or NULL
if there is no such object.
Nothing.
*this
is no longer associated with any Lockable
object. mutex()
returns NULL
and
owns_lock()
returns false
.
shared_lock()
shared_lock(Lockable &
m)
shared_lock(Lockable &
m,boost::adopt_lock_t)
shared_lock(Lockable &
m,boost::defer_lock_t)
shared_lock(Lockable &
m,boost::try_to_lock_t)
shared_lock(Lockable &
m,boost::system_time const& abs_time)
~shared_lock()
bool owns_lock() const
Lockable* mutex() const
explicit operator
bool()
const
Lockable* release()
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> template<typename Lockable> class shared_lock { public: typedef Lockable mutex_type; // Shared locking shared_lock(); explicit shared_lock(Lockable& m_); shared_lock(Lockable& m_,adopt_lock_t); shared_lock(Lockable& m_,defer_lock_t); shared_lock(Lockable& m_,try_to_lock_t); template <class Clock, class Duration> shared_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t); template <class Rep, class Period> shared_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d); ~shared_lock(); shared_lock(shared_lock const&) = delete; shared_lock& operator=(shared_lock const&) = delete; shared_lock(shared_lock<Lockable> && other); shared_lock& operator=(shared_lock<Lockable> && other); void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); // Conversion from upgrade locking explicit shared_lock(upgrade_lock<Lockable> && other); // EXTENSION // Conversion from exclusive locking explicit shared_lock(unique_lock<Lockable> && other); // Setters void swap(shared_lock& other); mutex_type* release() noexcept; // Getters explicit operator bool() const; bool owns_lock() const; mutex_type mutex() const; #if defined BOOST_THREAD_USE_DATE_TIME || defined BOOST_THREAD_DONT_USE_CHRONO shared_lock(Lockable& m_,system_time const& target_time); bool timed_lock(boost::system_time const& target_time); #endif };
Like boost::unique_lock
, boost::shared_lock
models the Lockable
concept, but rather than
acquiring unique ownership of the supplied Lockable
object, locking an instance
of boost::shared_lock
acquires shared ownership.
Like boost::unique_lock
, not only does it
provide for RAII-style locking, it also allows for deferring acquiring
the lock until the lock()
member function is called explicitly, or trying to acquire the lock in
a non-blocking fashion, or with a timeout. Consequently, unlock()
is only called in the destructor if the lock object has locked the Lockable
object, or otherwise
adopted a lock on the Lockable
object.
An instance of boost::shared_lock
is said to own
the lock state of a Lockable
m
if mutex()
returns a pointer to m
and owns_lock()
returns true
. If an object
that owns the lock state of a Lockable
object is destroyed,
then the destructor will invoke mutex()->unlock_shared()
.
The member functions of boost::shared_lock
are not thread-safe.
In particular, boost::shared_lock
is intended to model
the shared ownership of a Lockable
object by a particular
thread, and the member functions that release ownership of the lock state
(including the destructor) must be called by the same thread that acquired
ownership of the lock state.
Creates a lock object with no associated mutex.
owns_lock()
returns false
. mutex()
returns NULL
.
Nothing.
Stores a reference to m
.
Invokes m.lock_shared()
.
owns_lock()
returns true
. mutex()
returns &m
.
Any exception thrown by the call to m.lock_shared()
.
The current thread owns an exclusive lock on m
.
Stores a reference to m
.
Takes ownership of the lock state of m
.
owns_lock()
returns true
. mutex()
returns &m
.
Nothing.
Stores a reference to m
.
owns_lock()
returns false
. mutex()
returns &m
.
Nothing.
Stores a reference to m
.
Invokes m.try_lock_shared()
,
and takes ownership of the lock state if the call returns true
.
mutex()
returns &m
.
If the call to try_lock_shared()
returned true
, then
owns_lock()
returns true
, otherwise
owns_lock()
returns false
.
Nothing.
Stores a reference to m
.
Invokes m.timed_lock(abs_time)
,
and takes ownership of the lock state if the call returns true
.
mutex()
returns &m
.
If the call to timed_lock_shared()
returned true
, then
owns_lock()
returns true
, otherwise
owns_lock()
returns false
.
Any exceptions thrown by the call to m.timed_lock(abs_time)
.
Invokes mutex()
->
unlock_shared()
if owns_lock()
returns true
.
Nothing.
true
if the *this
owns the lock on the Lockable
object associated
with *this
.
Nothing.
A pointer to the Lockable
object associated
with *this
,
or NULL
if there
is no such object.
Nothing.
Nothing.
The association between *this
and the Lockable
object is removed,
without affecting the lock state of the Lockable
object. If owns_lock()
would have returned true
,
it is the responsibility of the calling code to ensure that the
Lockable
is correctly
unlocked.
A pointer to the Lockable
object associated
with *this
at the point of the call, or NULL
if there is no such object.
Nothing.
*this
is no longer associated with any Lockable
object. mutex()
returns NULL
and
owns_lock()
returns false
.
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> template<typename Lockable> class upgrade_lock { public: typedef Lockable mutex_type; // Upgrade locking upgrade_lock(); explicit upgrade_lock(mutex_type& m_); upgrade_lock(mutex_type& m, defer_lock_t) noexcept; upgrade_lock(mutex_type& m, try_to_lock_t); upgrade_lock(mutex_type& m, adopt_lock_t); template <class Clock, class Duration> upgrade_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time); template <class Rep, class Period> upgrade_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time); ~upgrade_lock(); upgrade_lock(const upgrade_lock& other) = delete; upgrade_lock& operator=(const upgrade_lock<Lockable> & other) = delete; upgrade_lock(upgrade_lock<Lockable> && other); upgrade_lock& operator=(upgrade_lock<Lockable> && other); void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION // Conversion from shared locking upgrade_lock(shared_lock<mutex_type>&& sl, try_to_lock_t); template <class Clock, class Duration> upgrade_lock(shared_lock<mutex_type>&& sl, const chrono::time_point<Clock, Duration>& abs_time); template <class Rep, class Period> upgrade_lock(shared_lock<mutex_type>&& sl, const chrono::duration<Rep, Period>& rel_time); #endif // Conversion from exclusive locking explicit upgrade_lock(unique_lock<Lockable> && other); // Setters void swap(upgrade_lock& other); mutex_type* release() noexcept; // Getters explicit operator bool() const; bool owns_lock() const; mutex_type mutex() const; };
Like boost::unique_lock
, boost::upgrade_lock
models the Lockable
concept, but rather than
acquiring unique ownership of the supplied Lockable
object, locking an instance
of boost::upgrade_lock
acquires upgrade
ownership.
Like boost::unique_lock
, not only does it
provide for RAII-style locking, it also allows for deferring acquiring
the lock until the lock()
member function is called explicitly, or trying to acquire the lock in
a non-blocking fashion, or with a timeout. Consequently, unlock()
is only called in the destructor if the lock object has locked the Lockable
object, or otherwise
adopted a lock on the Lockable
object.
An instance of boost::upgrade_lock
is said to own
the lock state of a Lockable
m
if mutex()
returns a pointer to m
and owns_lock()
returns true
. If an object
that owns the lock state of a Lockable
object is destroyed,
then the destructor will invoke mutex()->unlock_upgrade()
.
The member functions of boost::upgrade_lock
are not thread-safe.
In particular, boost::upgrade_lock
is intended to model
the upgrade ownership of a UpgradeLockable
object by a particular
thread, and the member functions that release ownership of the lock state
(including the destructor) must be called by the same thread that acquired
ownership of the lock state.
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> template <class Lockable> class upgrade_to_unique_lock { public: typedef Lockable mutex_type; explicit upgrade_to_unique_lock(upgrade_lock<Lockable>& m_); ~upgrade_to_unique_lock(); upgrade_to_unique_lock(upgrade_to_unique_lock const& other) = delete; upgrade_to_unique_lock& operator=(upgrade_to_unique_lock<Lockable> const& other) = delete; upgrade_to_unique_lock(upgrade_to_unique_lock<Lockable> && other); upgrade_to_unique_lock& operator=(upgrade_to_unique_lock<Lockable> && other); void swap(upgrade_to_unique_lock& other); explicit operator bool() const; bool owns_lock() const; mutex_type* mutex() const; };
boost::upgrade_to_unique_lock
allows
for a temporary upgrade of an boost::upgrade_lock
to exclusive ownership.
When constructed with a reference to an instance of boost::upgrade_lock
, if that instance
has upgrade ownership on some Lockable
object, that ownership
is upgraded to exclusive ownership. When the boost::upgrade_to_unique_lock
instance
is destroyed, the ownership of the Lockable
is downgraded back to
upgrade ownership.
class MutexType::scoped_try_lock { private: MutexType::scoped_try_lock(MutexType::scoped_try_lock<MutexType>& other); MutexType::scoped_try_lock& operator=(MutexType::scoped_try_lock<MutexType>& other); public: MutexType::scoped_try_lock(); explicit MutexType::scoped_try_lock(MutexType& m); MutexType::scoped_try_lock(MutexType& m_,adopt_lock_t); MutexType::scoped_try_lock(MutexType& m_,defer_lock_t); MutexType::scoped_try_lock(MutexType& m_,try_to_lock_t); MutexType::scoped_try_lock(MutexType::scoped_try_lock<MutexType>&& other); MutexType::scoped_try_lock& operator=(MutexType::scoped_try_lock<MutexType>&& other); void swap(MutexType::scoped_try_lock&& other); void lock(); bool try_lock(); void unlock(); MutexType* mutex() const; MutexType* release(); explicit operator bool() const; bool owns_lock() const; };
The member typedef scoped_try_lock
is provided for each distinct MutexType
as a typedef to a class with the preceding definition. The semantics of
each constructor and member function are identical to those of boost::unique_lock<MutexType>
for the same MutexType
,
except that the constructor that takes a single reference to a mutex will
call m.try_lock()
rather than m.lock()
.
// #include <boost/thread/locks.hpp> // #include <boost/thread/strict_lock.hpp> namespace boost { template<typename Lockable> class strict_lock; template <typename Lock> class nested_strict_lock; template <typename Lockable> struct is_strict_lock_sur_parole<strict_lock<Lockable> >; template <typename Lock> struct is_strict_lock_sur_parole<nested_strict_lock<Lock> >; #if ! defined BOOST_THREAD_NO_MAKE_STRICT_LOCK template <typename Lockable> strict_lock<Lockable> make_strict_lock(Lockable& mtx); #endif #if ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK template <typename Lock> nested_strict_lock<Lock> make_nested_strict_lock(Lock& lk); #endif }
// #include <boost/thread/locks.hpp> // #include <boost/thread/strict_lock.hpp> template<typename BasicLockable> class strict_lock { public: typedef BasicLockable mutex_type; strict_lock(strict_lock const& m_) = delete; strict_lock& operator=(strict_lock const& m_) = delete; explicit strict_lock(mutex_type& m_); ~strict_lock(); bool owns_lock(mutex_type const* l) const noexcept; };
strict_lock
is a model of StrictLock
.
strict_lock
is the simplest
StrictLock
: on construction
it acquires ownership of the implementation of the BasicLockable
concept supplied
as the constructor parameter. On destruction, the ownership is released.
This provides simple RAII-style locking of a BasicLockable
object, to facilitate
exception-safe locking and unlocking.
boost::lock_guard
Invokes m.unlock()
on the Lockable
object passed
to the constructor.
Nothing.
// #include <boost/thread/locks.hpp> // #include <boost/thread/strict_lock.hpp> template<typename Lock> class nested_strict_lock { public: typedef BasicLockable mutex_type; nested_strict_lock(nested_strict_lock const& m_) = delete; nested_strict_lock& operator=(nested_strict_lock const& m_) = delete; explicit nested_strict_lock(Lock& lk), ~nested_strict_lock() noexcept; bool owns_lock(mutex_type const* l) const noexcept; };
nested_strict_lock
is a model
of StrictLock
.
A nested strict lock is a scoped lock guard ensuring a mutex is locked on its scope, by taking ownership of an nesting lock, locking the mutex on construction if not already locked and restoring the ownership to the nesting lock on destruction.
strict_lock
, boost::unique_lock
lk.mutex()
!= null_ptr
.
Stores the reference to the lock parameter lk
and takes ownership on it. If the lock doesn't owns the mutex
lock it.
owns_lock(lk.mutex())
.
- lock_error when BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED is defined and lk.mutex() == null_ptr
- Any exception that @c lk.lock() can throw.
Restores ownership to the nesting lock.
Whether if this lock is locking that mutex.
template <typename Lockable> strict_lock<Lockable> make_strict_lock(Lockable& m); // EXTENSION
a strict_lock as if initialized with {m}
.
Any exception thrown by the call to m.lock()
.
template <typename Lock> nested_strict_lock<Lock> make_nested_strict_lock(Lock& lk); // EXTENSION
a nested_strict_lock as if initialized with {lk}
.
Any exception thrown by the call to lk.lock()
.
// #include <boost/thread/synchroniezd_value.hpp> // #include <boost/thread/strict_lock_ptr.hpp> namespace boost { template<typename T, typename Lockable = mutex> class strict_lock_ptr; template<typename T, typename Lockable = mutex> class const_strict_lock_ptr; }
// #include <boost/thread/synchroniezd_value.hpp> // #include <boost/thread/strict_lock_ptr.hpp> template <typename T, typename Lockable = mutex> class const_strict_lock_ptr { public: typedef T value_type; typedef Lockable mutex_type; const_strict_lock_ptr(const_strict_lock_ptr const& m_) = delete; const_strict_lock_ptr& operator=(const_strict_lock_ptr const& m_) = delete; const_strict_lock_ptr(T const& val, Lockable & mtx); const_strict_lock_ptr(T const& val, Lockable & mtx, adopt_lock_t tag); ~const_strict_lock_ptr(); const T* operator->() const; const T& operator*() const; };
const_strict_lock_ptr(T const& val, Lockable & m);
const_strict_lock_ptr(T const& val, Lockable & m, adopt_lock_t tag);
Stores a reference to it and to the value type val
.
Nothing.
~const_strict_lock_ptr();
Invokes m.unlock()
on the Lockable
object passed
to the constructor.
Nothing.
const T* operator->() const;
return a constant pointer to the protected value.
Nothing.
const T& operator*() const;
return a constant reference to the protected value.
Nothing.
// #include <boost/thread/synchroniezd_value.hpp> // #include <boost/thread/strict_lock_ptr.hpp> template <typename T, typename Lockable = mutex> class strict_lock_ptr : public const_strict_lock_ptr<T,Lockable> { public: strict_lock_ptr(strict_lock_ptr const& m_) = delete; strict_lock_ptr& operator=(strict_lock_ptr const& m_) = delete; strict_lock_ptr(T & val, Lockable & mtx); strict_lock_ptr(T & val, Lockable & mtx, adopt_lock_t tag); ~strict_lock_ptr(); T* operator->(); T& operator*(); };
strict_lock_ptr(T const& val, Lockable & m);
strict_lock_ptr(T const& val, Lockable & m, adopt_lock_t tag);
Stores a reference to it and to the value type val
.
Nothing.
~ strict_lock_ptr();
Invokes m.unlock()
on the Lockable
object passed
to the constructor.
Nothing.
// #include <boost/thread/externally_locked.hpp> template <class T, typename MutexType = boost::mutex> class externally_locked; template <class T, typename MutexType> class externally_locked<T&, MutexType>; template <typename T, typename MutexType> void swap(externally_locked<T, MutexType> & lhs, externally_locked<T, MutexType> & rhs);
// #include <boost/thread/externally_locked.hpp> template <class T, typename MutexType> class externally_locked { //BOOST_CONCEPT_ASSERT(( CopyConstructible<T> )); BOOST_CONCEPT_ASSERT(( BasicLockable<MutexType> )); public: typedef MutexType mutex_type; externally_locked(mutex_type& mtx, const T& obj); externally_locked(mutex_type& mtx,T&& obj); explicit externally_locked(mutex_type& mtx); externally_locked(externally_locked const& rhs); externally_locked(externally_locked&& rhs); externally_locked& operator=(externally_locked const& rhs); externally_locked& operator=(externally_locked&& rhs); // observers T& get(strict_lock<mutex_type>& lk); const T& get(strict_lock<mutex_type>& lk) const; template <class Lock> T& get(nested_strict_lock<Lock>& lk); template <class Lock> const T& get(nested_strict_lock<Lock>& lk) const; template <class Lock> T& get(Lock& lk); template <class Lock> T const& get(Lock& lk) const; mutex_type* mutex() const noexcept; // modifiers void lock(); void unlock(); bool try_lock(); void swap(externally_locked&); };
externally_locked
is
a model of Lockable
, it cloaks an object
of type T
, and actually
provides full access to that object through the get and set member functions,
provided you pass a reference to a strict lock object.
Only the specificities respect to Lockable
are described here.
externally_locked(mutex_type& mtx, const T& obj);
T is a model of CopyConstructible.
Constructs an externally locked object copying the cloaked type.
Any exception thrown by the call to T(obj)
.
externally_locked(mutex_type& mtx,T&& obj);
T is a model of Movable.
Constructs an externally locked object by moving the cloaked type.
Any exception thrown by the call to T(obj)
.
externally_locked(mutex_type& mtx);
T is a model of DefaultConstructible.
Constructs an externally locked object by default constructing the cloaked type.
Any exception thrown by the call to T()
.
externally_locked(externally_locked&& rhs);
T is a model of Movable.
Move constructs an externally locked object by moving the cloaked type and copying the mutex reference
Any exception thrown by the call to T(T&&)
.
externally_locked(externally_locked& rhs);
T is a model of Copyable.
Copy constructs an externally locked object by copying the cloaked type and copying the mutex reference
Any exception thrown by the call to T(T&)
.
externally_locked& operator=(externally_locked&& rhs);
T is a model of Movable.
Move assigns an externally locked object by moving the cloaked type and copying the mutex reference
Any exception thrown by the call to T::operator=(T&&)
.
externally_locked& operator=(externally_locked const& rhs);
T is a model of Copyable.
Copy assigns an externally locked object by copying the cloaked type and copying the mutex reference
Any exception thrown by the call to T::operator=(T&)
.
T& get(strict_lock<mutex_type>& lk); const T& get(strict_lock<mutex_type>& lk) const;
The lk
parameter
must be locking the associated mutex.
A reference to the cloaked object
lock_error
if
BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
is defined and the run-time preconditions are not satisfied .
template <class Lock> T& get(nested_strict_lock<Lock>& lk); template <class Lock> const T& get(nested_strict_lock<Lock>& lk) const;
is_same<mutex_type,
typename Lock::mutex_type>
and the lk
parameter must be locking the associated mutex.
A reference to the cloaked object
lock_error
if
BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
is defined and the run-time preconditions are not satisfied .
template <class Lock> T& get(Lock& lk); template <class Lock> T const& get(Lock& lk) const;
Lock
is a model
of StrictLock
, is_same<mutex_type,
typename Lock::mutex_type>
and the lk
parameter must be locking the associated mutex.
A reference to the cloaked object
lock_error
if
BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
is defined and the run-time preconditions are not satisfied .
// #include <boost/thread/externally_locked.hpp> template <class T, typename MutexType> class externally_locked<T&, MutexType> { //BOOST_CONCEPT_ASSERT(( CopyConstructible<T> )); BOOST_CONCEPT_ASSERT(( BasicLockable<MutexType> )); public: typedef MutexType mutex_type; externally_locked(mutex_type& mtx, T& obj); explicit externally_locked(mutex_type& mtx); externally_locked(externally_locked const& rhs) noexcept; externally_locked(externally_locked&& rhs) noexcept; externally_locked& operator=(externally_locked const& rhs) noexcept; externally_locked& operator=(externally_locked&& rhs) noexcept; // observers T& get(strict_lock<mutex_type>& lk); const T& get(strict_lock<mutex_type>& lk) const; template <class Lock> T& get(nested_strict_lock<Lock>& lk); template <class Lock> const T& get(nested_strict_lock<Lock>& lk) const; template <class Lock> T& get(Lock& lk); template <class Lock> T const& get(Lock& lk) const; mutex_type* mutex() const noexcept; // modifiers void lock(); void unlock(); bool try_lock(); void swap(externally_locked&) noexcept; };
externally_locked
is
a model of Lockable
, it cloaks an object
of type T
, and actually
provides full access to that object through the get and set member functions,
provided you pass a reference to a strict lock object.
Only the specificities respect to Lockable
are described here.
externally_locked<T&>(mutex_type& mtx, T& obj) noexcept;
Constructs an externally locked object copying the cloaked reference.
externally_locked(externally_locked&& rhs) noexcept;
Moves an externally locked object by moving the cloaked type and copying the mutex reference
externally_locked& operator=(externally_locked&& rhs);
Move assigns an externally locked object by copying the cloaked reference and copying the mutex reference
externally_locked& operator=(externally_locked const& rhs);
T is a model of Copyable.
Copy assigns an externally locked object by copying the cloaked reference and copying the mutex reference
Any exception thrown by the call to T::operator=(T&)
.
T& get(strict_lock<mutex_type>& lk); const T& get(strict_lock<mutex_type>& lk) const;
The lk
parameter
must be locking the associated mutex.
A reference to the cloaked object
lock_error
if
BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
is defined and the run-time preconditions are not satisfied .
template <class Lock> T& get(nested_strict_lock<Lock>& lk); template <class Lock> const T& get(nested_strict_lock<Lock>& lk) const;
is_same<mutex_type,
typename Lock::mutex_type>
and the lk
parameter must be locking the associated mutex.
A reference to the cloaked object
lock_error
if
BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
is defined and the run-time preconditions are not satisfied .
template <class Lock> T& get(Lock& lk); template <class Lock> T const& get(Lock& lk) const;
Lock
is a model
of StrictLock
, is_same<mutex_type,
typename Lock::mutex_type>
and the lk
parameter must be locking the associated mutex.
A reference to the cloaked object
lock_error
if
BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
is defined and the run-time preconditions are not satisfied .
template <typename T, typename MutexType> void swap(externally_locked<T, MutexType> & lhs, externally_locked<T, MutexType> & rhs)
// #include <boost/thread/shared_lock_guard.hpp> namespace boost { template<typename SharedLockable> class shared_lock_guard { public: shared_lock_guard(shared_lock_guard const&) = delete; shared_lock_guard& operator=(shared_lock_guard const&) = delete; explicit shared_lock_guard(SharedLockable& m_); shared_lock_guard(SharedLockable& m_,boost::adopt_lock_t); ~shared_lock_guard(); }; }
shared_lock_guard
is very simple:
on construction it acquires shared ownership of the implementation of the
SharedLockable
concept supplied
as the constructor parameter. On destruction, the ownership is released.
This provides simple RAII-style locking of a SharedLockable
object, to facilitate
exception-safe shared locking and unlocking. In addition, the
constructor allows the shared_lock_guard
(SharedLockable &m, boost::adopt_lock_t)shared_lock_guard
object to take
shared ownership of a lock already held by the current thread.
Stores a reference to m
.
Invokes m.
.
lock_shared()
()
Any exception thrown by the call to m.
.
lock_shared()
()
The current thread owns a lock on m
equivalent to one obtained by a call to m.
.
lock_shared()
()
Stores a reference to m
.
Takes ownership of the lock state of m
.
Nothing.
Invokes m.
on the unlock_shared()
()SharedLockable
object
passed to the constructor.
Nothing.
// #include <boost/thread/reverse_lock.hpp> namespace boost { template<typename Lock> class reverse_lock { public: reverse_lock(reverse_lock const&) = delete; reverse_lock& operator=(reverse_lock const&) = delete; explicit reverse_lock(Lock& m_); ~reverse_lock(); }; }
reverse_lock
reverse the operations
of a lock: it provide for RAII-style, that unlocks the lock at construction
time and lock it at destruction time. In addition, it transfer ownership
temporarily, so that the mutex can not be locked using the Lock.
An instance of reverse_lock
doesn't own
the lock never.
Stores a reference to m
.
Invokes m.
if unlock
()m
owns his lock
and then stores the mutex by calling m.release()
.
!m.
.
owns_lock()
() &&
m.mutex()==0
Any exception thrown by the call to m.
.
unlock
()
Let be mtx the stored mutex*. If not 0 Invokes mtx->
and gives again the lock
()mtx
to the Lock
using
the adopt_lock_t
overload.
Any exception thrown by mtx->
.
lock
()
Note that if mtx->
throws an exception while unwinding the program will terminate,
so don't use reverse_lock if an exception can be thrown.
lock
()
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_algorithms.hpp> namespace boost { template<typename Lockable1,typename Lockable2> void lock(Lockable1& l1,Lockable2& l2); template<typename Lockable1,typename Lockable2,typename Lockable3> void lock(Lockable1& l1,Lockable2& l2,Lockable3& l3); template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4> void lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4); template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4,typename Lockable5> void lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4,Lockable5& l5); }
Locks the Lockable
objects supplied
as arguments in an unspecified and indeterminate order in a way that
avoids deadlock. It is safe to call this function concurrently from
multiple threads with the same mutexes (or other lockable objects)
in different orders without risk of deadlock. If any of the lock()
or try_lock()
operations on the supplied Lockable
objects throws
an exception any locks acquired by the function will be released
before the function exits.
Any exceptions thrown by calling lock()
or try_lock()
on the supplied Lockable
objects.
All the supplied Lockable
objects are locked
by the calling thread.
template<typename ForwardIterator> void lock(ForwardIterator begin,ForwardIterator end);
The value_type
of
ForwardIterator
must
implement the Lockable
concept
Locks all the Lockable
objects in the
supplied range in an unspecified and indeterminate order in a way
that avoids deadlock. It is safe to call this function concurrently
from multiple threads with the same mutexes (or other lockable objects)
in different orders without risk of deadlock. If any of the lock()
or try_lock()
operations on the Lockable
objects in the
supplied range throws an exception any locks acquired by the function
will be released before the function exits.
Any exceptions thrown by calling lock()
or try_lock()
on the supplied Lockable
objects.
All the Lockable
objects in the
supplied range are locked by the calling thread.
template<typename Lockable1,typename Lockable2> int try_lock(Lockable1& l1,Lockable2& l2); template<typename Lockable1,typename Lockable2,typename Lockable3> int try_lock(Lockable1& l1,Lockable2& l2,Lockable3& l3); template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4> int try_lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4); template<typename Lockable1,typename Lockable2,typename Lockable3,typename Lockable4,typename Lockable5> int try_lock(Lockable1& l1,Lockable2& l2,Lockable3& l3,Lockable4& l4,Lockable5& l5);
Calls try_lock()
on each of the Lockable
objects supplied
as arguments. If any of the calls to try_lock()
returns false
then all
locks acquired are released and the zero-based index of the failed
lock is returned.
If any of the try_lock()
operations on the supplied Lockable
objects throws
an exception any locks acquired by the function will be released
before the function exits.
-1
if all the supplied Lockable
objects are now
locked by the calling thread, the zero-based index of the object
which could not be locked otherwise.
Any exceptions thrown by calling try_lock()
on the supplied Lockable
objects.
If the function returns -1
, all the supplied Lockable
objects are locked
by the calling thread. Otherwise any locks acquired by this function
will have been released.
template<typename ForwardIterator> ForwardIterator try_lock(ForwardIterator begin,ForwardIterator end);
The value_type
of
ForwardIterator
must
implement the Lockable
concept
Calls try_lock()
on each of the Lockable
objects in the
supplied range. If any of the calls to try_lock()
returns false
then all
locks acquired are released and an iterator referencing the failed
lock is returned.
If any of the try_lock()
operations on the supplied Lockable
objects throws
an exception any locks acquired by the function will be released
before the function exits.
end
if all the supplied
Lockable
objects are now
locked by the calling thread, an iterator referencing the object
which could not be locked otherwise.
Any exceptions thrown by calling try_lock()
on the supplied Lockable
objects.
If the function returns end
then all the Lockable
objects in the
supplied range are locked by the calling thread, otherwise all locks
acquired by the function have been released.
namespace boost { template <typename Lockable> unique_lock<Lockable> make_unique_lock(Lockable& mtx); // EXTENSION template <typename Lockable> unique_lock<Lockable> make_unique_lock(Lockable& mtx, adopt_lock_t); // EXTENSION template <typename Lockable> unique_lock<Lockable> make_unique_lock(Lockable& mtx, defer_lock_t); // EXTENSION template <typename Lockable> unique_lock<Lockable> make_unique_lock(Lockable& mtx, try_to_lock_t); // EXTENSION #if ! defined(BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS) template <typename ...Lockable> std::tuple<unique_lock<Lockable> ...> make_unique_locks(Lockable& ...mtx); // EXTENSION #endif }
template <typename Lockable> unique_lock<Lockable> make_unique_lock(Lockable& mtx); // EXTENSION
a boost::unique_lock
as if initialized
with unique_lock<Lockable>(mtx)
.
Any exception thrown by the call to
.
boost::unique_lock
<Lockable>(mtx)
template <typename Lockable> unique_lock<Lockable> make_unique_lock(Lockable& mtx, adopt_lock_t tag); // EXTENSION template <typename Lockable> unique_lock<Lockable> make_unique_lock(Lockable& mtx, defer_lock_t tag); // EXTENSION template <typename Lockable> unique_lock<Lockable> make_unique_lock(Lockable& mtx, try_to_lock_t tag); // EXTENSION
a boost::unique_lock
as if initialized
with unique_lock<Lockable>(mtx, tag)
.
Any exception thrown by the call to
.
boost::unique_lock
<Lockable>(mtx,
tag)
template <typename ...Lockable> std::tuple<unique_lock<Lockable> ...> make_unique_locks(Lockable& ...mtx); // EXTENSION
Locks all the mutexes.
a std::tuple of unique boost::unique_lock
owning each
one of the mutex.
Any exception thrown by boost::lock(mtx...)
.
#include <boost/thread/mutex.hpp> class mutex: boost::noncopyable { public: mutex(); ~mutex(); void lock(); bool try_lock(); void unlock(); typedef platform-specific-type native_handle_type; native_handle_type native_handle(); typedef unique_lock<mutex> scoped_lock; typedef unspecified-type scoped_try_lock; };
boost::mutex
implements the Lockable
concept to provide an
exclusive-ownership mutex. At most one thread can own the lock on a given
instance of boost::mutex
at any time. Multiple concurrent
calls to lock()
,
try_lock()
and unlock()
shall be permitted.
typedef platform-specific-type native_handle_type; native_handle_type native_handle();
Returns an instance of native_handle_type
that can be used with platform-specific APIs to manipulate the
underlying implementation. If no such instance exists, native_handle()
and native_handle_type
are not present.
Nothing.
#include <boost/thread/mutex.hpp> typedef mutex try_mutex;
boost::try_mutex
is a typedef
to boost::mutex
, provided for backwards
compatibility with previous releases of boost.
#include <boost/thread/mutex.hpp> class timed_mutex: boost::noncopyable { public: timed_mutex(); ~timed_mutex(); void lock(); void unlock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& t); typedef platform-specific-type native_handle_type; native_handle_type native_handle(); typedef unique_lock<timed_mutex> scoped_timed_lock; typedef unspecified-type scoped_try_lock; typedef scoped_timed_lock scoped_lock; #if defined BOOST_THREAD_PROVIDES_DATE_TIME || defined BOOST_THREAD_DONT_USE_CHRONO bool timed_lock(system_time const & abs_time); template<typename TimeDuration> bool timed_lock(TimeDuration const & relative_time); #endif };
boost::timed_mutex
implements the TimedLockable
concept to provide
an exclusive-ownership mutex. At most one thread can own the lock on a
given instance of boost::timed_mutex
at any time. Multiple
concurrent calls to lock()
,
try_lock()
,
timed_lock()
,
timed_lock()
and unlock()
shall be permitted.
typedef platform-specific-type native_handle_type; native_handle_type native_handle();
Returns an instance of native_handle_type
that can be used with platform-specific APIs to manipulate the
underlying implementation. If no such instance exists, native_handle()
and native_handle_type
are not present.
Nothing.
#include <boost/thread/recursive_mutex.hpp> class recursive_mutex: boost::noncopyable { public: recursive_mutex(); ~recursive_mutex(); void lock(); bool try_lock() noexcept; void unlock(); typedef platform-specific-type native_handle_type; native_handle_type native_handle(); typedef unique_lock<recursive_mutex> scoped_lock; typedef unspecified-type scoped_try_lock; };
boost::recursive_mutex
implements the
Lockable
concept to provide an
exclusive-ownership recursive mutex. At most one thread can own the lock
on a given instance of boost::recursive_mutex
at any time. Multiple
concurrent calls to lock()
,
try_lock()
and unlock()
shall be permitted. A thread that already has exclusive ownership of a
given boost::recursive_mutex
instance can call
lock()
or try_lock()
to acquire an additional level of ownership of the mutex. unlock()
must be called once for each level of ownership acquired by a single thread
before ownership can be acquired by another thread.
typedef platform-specific-type native_handle_type; native_handle_type native_handle();
Returns an instance of native_handle_type
that can be used with platform-specific APIs to manipulate the
underlying implementation. If no such instance exists, native_handle()
and native_handle_type
are not present.
Nothing.
#include <boost/thread/recursive_mutex.hpp> typedef recursive_mutex recursive_try_mutex;
boost::recursive_try_mutex
is a typedef
to boost::recursive_mutex
, provided for
backwards compatibility with previous releases of boost.
#include <boost/thread/recursive_mutex.hpp> class recursive_timed_mutex: boost::noncopyable { public: recursive_timed_mutex(); ~recursive_timed_mutex(); void lock(); bool try_lock() noexcept; void unlock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& t); typedef platform-specific-type native_handle_type; native_handle_type native_handle(); typedef unique_lock<recursive_timed_mutex> scoped_lock; typedef unspecified-type scoped_try_lock; typedef scoped_lock scoped_timed_lock; #if defined BOOST_THREAD_PROVIDES_DATE_TIME || defined BOOST_THREAD_DONT_USE_CHRONO bool timed_lock(system_time const & abs_time); template<typename TimeDuration> bool timed_lock(TimeDuration const & relative_time); #endif };
boost::recursive_timed_mutex
implements
the TimedLockable
concept to provide
an exclusive-ownership recursive mutex. At most one thread can own the
lock on a given instance of boost::recursive_timed_mutex
at any time.
Multiple concurrent calls to lock()
,
try_lock()
,
timed_lock()
,
timed_lock()
and unlock()
shall be permitted. A thread that already has exclusive ownership of a
given boost::recursive_timed_mutex
instance
can call lock()
,
timed_lock()
,
timed_lock()
or try_lock()
to acquire an additional level of ownership of the mutex. unlock()
must be called once for each level of ownership acquired by a single thread
before ownership can be acquired by another thread.
typedef platform-specific-type native_handle_type; native_handle_type native_handle();
Returns an instance of native_handle_type
that can be used with platform-specific APIs to manipulate the
underlying implementation. If no such instance exists, native_handle()
and native_handle_type
are not present.
Nothing.
#include <boost/thread/shared_mutex.hpp> class shared_mutex { public: shared_mutex(shared_mutex const&) = delete; shared_mutex& operator=(shared_mutex const&) = delete; shared_mutex(); ~shared_mutex(); void lock_shared(); bool try_lock_shared(); template <class Rep, class Period> bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock_shared(); void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); #if defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 // use upgrade_mutex instead. void lock_upgrade(); // EXTENSION void unlock_upgrade(); // EXTENSION void unlock_upgrade_and_lock(); // EXTENSION void unlock_and_lock_upgrade(); // EXTENSION void unlock_and_lock_shared(); // EXTENSION void unlock_upgrade_and_lock_shared(); // EXTENSION #endif #if defined BOOST_THREAD_USES_DATETIME bool timed_lock_shared(system_time const& timeout); // DEPRECATED bool timed_lock(system_time const& timeout); // DEPRECATED #endif };
The class boost::shared_mutex
provides an implementation
of a multiple-reader / single-writer mutex. It implements the SharedLockable
concept.
Multiple concurrent calls to lock()
,
try_lock()
,
,
try_lock_for
()
,
try_lock_until
()timed_lock()
,
lock_shared()
,
,
try_lock_shared_for
()
,
try_lock_shared_until
()try_lock_shared()
and timed_lock_shared()
are permitted.
Note the the lack of reader-writer priority policies in shared_mutex. This is due to an algorithm credited to Alexander Terekhov which lets the OS decide which thread is the next to get the lock without caring whether a unique lock or shared lock is being sought. This results in a complete lack of reader or writer starvation. It is simply fair.
#include <boost/thread/shared_mutex.hpp> class upgrade_mutex { public: upgrade_mutex(upgrade_mutex const&) = delete; upgrade_mutex& operator=(upgrade_mutex const&) = delete; upgrade_mutex(); ~upgrade_mutex(); void lock_shared(); bool try_lock_shared(); template <class Rep, class Period> bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock_shared(); void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); void lock_upgrade(); template <class Rep, class Period> bool try_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock_upgrade(); // Shared <-> Exclusive #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS bool try_unlock_shared_and_lock(); template <class Rep, class Period> bool try_unlock_shared_and_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_unlock_shared_and_lock_until(const chrono::time_point<Clock, Duration>& abs_time); #endif void unlock_and_lock_shared(); // Shared <-> Upgrade #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS bool try_unlock_shared_and_lock_upgrade(); template <class Rep, class Period> bool try_unlock_shared_and_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_unlock_shared_and_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time); #endif void unlock_upgrade_and_lock_shared(); // Upgrade <-> Exclusive void unlock_upgrade_and_lock(); #if defined(BOOST_THREAD_PLATFORM_PTHREAD) || defined(BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN) bool try_unlock_upgrade_and_lock(); template <class Rep, class Period> bool try_unlock_upgrade_and_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_unlock_upgrade_and_lock_until(const chrono::time_point<Clock, Duration>& abs_time); #endif void unlock_and_lock_upgrade(); };
The class boost::upgrade_mutex
provides an implementation
of a multiple-reader / single-writer mutex. It implements the UpgradeLockable
concept.
Multiple concurrent calls to lock()
,
try_lock()
,
,
try_lock_for
()
,
try_lock_until
()timed_lock()
,
lock_shared()
,
,
try_lock_shared_for
()
,
try_lock_shared_until
()try_lock_shared()
and timed_lock_shared()
are permitted.
#include <boost/thread/null_mutex.hpp> class null_mutex { public: null_mutex(null_mutex const&) = delete; null_mutex& operator=(null_mutex const&) = delete; null_mutex(); ~null_mutex(); void lock_shared(); bool try_lock_shared(); #ifdef BOOST_THREAD_USES_CHRONO template <class Rep, class Period> bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time); #endif void unlock_shared(); void lock(); bool try_lock(); #ifdef BOOST_THREAD_USES_CHRONO template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); #endif void unlock(); void lock_upgrade(); #ifdef BOOST_THREAD_USES_CHRONO template <class Rep, class Period> bool try_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time); #endif void unlock_upgrade(); // Shared <-> Exclusive bool try_unlock_shared_and_lock(); #ifdef BOOST_THREAD_USES_CHRONO template <class Rep, class Period> bool try_unlock_shared_and_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_unlock_shared_and_lock_until(const chrono::time_point<Clock, Duration>& abs_time); #endif void unlock_and_lock_shared(); // Shared <-> Upgrade bool try_unlock_shared_and_lock_upgrade(); #ifdef BOOST_THREAD_USES_CHRONO template <class Rep, class Period> bool try_unlock_shared_and_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_unlock_shared_and_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time); #endif void unlock_upgrade_and_lock_shared(); // Upgrade <-> Exclusive void unlock_upgrade_and_lock(); bool try_unlock_upgrade_and_lock(); #ifdef BOOST_THREAD_USES_CHRONO template <class Rep, class Period> bool try_unlock_upgrade_and_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_unlock_upgrade_and_lock_until(const chrono::time_point<Clock, Duration>& abs_time); #endif void unlock_and_lock_upgrade(); };
The class boost::null_mutex
provides a no-op implementation
of a multiple-reader / single-writer mutex. It is a model of the UpgradeLockable
concept.
namespace boost { enum class cv_status; { no_timeout, timeout }; class condition_variable; class condition_variable_any; void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); }
The classes condition_variable
and condition_variable_any
provide a mechanism for one thread to wait for notification from another
thread that a particular condition has become true. The general usage pattern
is that one thread locks a mutex and then calls wait
on an instance of condition_variable
or condition_variable_any
.
When the thread is woken from the wait, then it checks to see if the appropriate
condition is now true, and continues if so. If the condition is not true,
then the thread then calls wait
again to resume waiting. In the simplest case, this condition is just a boolean
variable:
boost::condition_variable cond; boost::mutex mut; bool data_ready; void process_data(); void wait_for_data_to_process() { boost::unique_lock<boost::mutex> lock(mut); while(!data_ready) { cond.wait(lock); } process_data(); }
Notice that the lock
is passed
to wait
: wait
will atomically add the thread to the set of threads waiting on the condition
variable, and unlock the mutex. When the thread is woken, the mutex will
be locked again before the call to wait
returns. This allows other threads to acquire the mutex in order to update
the shared data, and ensures that the data associated with the condition
is correctly synchronized.
In the mean time, another thread sets the condition to true
,
and then calls either notify_one
or notify_all
on the condition
variable to wake one waiting thread or all the waiting threads respectively.
void retrieve_data(); void prepare_data(); void prepare_data_for_processing() { retrieve_data(); prepare_data(); { boost::lock_guard<boost::mutex> lock(mut); data_ready=true; } cond.notify_one(); }
Note that the same mutex is locked before the shared data is updated, but
that the mutex does not have to be locked across the call to notify_one
.
This example uses an object of type condition_variable
,
but would work just as well with an object of type condition_variable_any
:
condition_variable_any
is
more general, and will work with any kind of lock or mutex, whereas condition_variable
requires that the lock
passed to wait
is an instance
of boost::unique_lock<boost::mutex>
.
This enables condition_variable
to make optimizations in some cases, based on the knowledge of the mutex
type; condition_variable_any
typically has a more complex implementation than condition_variable
.
condition_variable()
~condition_variable()
void notify_one()
void notify_all()
void wait(boost::unique_lock<boost::mutex>& lock)
template<typename predicate_type> void wait(boost::unique_lock<boost::mutex>&
lock,
predicate_type pred)
bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time
const&
abs_time)
template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>&
lock,duration_type const& rel_time)
template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>&
lock,
boost::system_time const& abs_time, predicate_type
pred)
template <class Clock, class Duration>
cv_status wait_until(boost::unique_lock<boost::mutex>& lock, const chrono::time_point<Clock, Duration>&
abs_time)
template <class Rep, class Period>
cv_status wait_for(boost::unique_lock<boost::mutex>& lock, const chrono::duration<Rep, Period>&
rel_time)
template <class Clock, class Duration, class Predicate> bool wait_until(boost::unique_lock<boost::mutex>&
lock,
const chrono::time_point<Clock, Duration>& abs_time, Predicate
pred)
template <class Rep, class Period, class Predicate> bool wait_for(boost::unique_lock<boost::mutex>&
lock,
const chrono::duration<Rep, Period>& rel_time, Predicate
pred)
//#include <boost/thread/condition_variable.hpp> namespace boost { class condition_variable { public: condition_variable(); ~condition_variable(); void notify_one() noexcept; void notify_all() noexcept; void wait(boost::unique_lock<boost::mutex>& lock); template<typename predicate_type> void wait(boost::unique_lock<boost::mutex>& lock,predicate_type predicate); template <class Clock, class Duration> typename cv_status::type wait_until( unique_lock<mutex>& lock, const chrono::time_point<Clock, Duration>& t); template <class Clock, class Duration, class Predicate> bool wait_until( unique_lock<mutex>& lock, const chrono::time_point<Clock, Duration>& t, Predicate pred); template <class Rep, class Period> typename cv_status::type wait_for( unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& d); template <class Rep, class Period, class Predicate> bool wait_for( unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& d, Predicate pred); #if defined BOOST_THREAD_USES_DATETIME bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time); template<typename duration_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time); template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time,predicate_type predicate); template<typename duration_type,typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time,predicate_type predicate); bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time); template<typename predicate_type> bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::xtime const& abs_time,predicate_type predicate); #endif }; }
Constructs an object of class condition_variable
.
boost::thread_resource_error
if an error
occurs.
All threads waiting on *this
have been notified by a call
to notify_one
or
notify_all
(though
the respective calls to wait
or timed_wait
need
not have returned).
Destroys the object.
Nothing.
If any threads are currently blocked waiting
on *this
in a call to wait
or timed_wait
,
unblocks one of those threads.
Nothing.
If any threads are currently blocked waiting
on *this
in a call to wait
or timed_wait
,
unblocks all of those threads.
Nothing.
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
timed_wait
in all
the threads currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
As-if
while(!pred()) { wait(lock); }
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
timed_wait
in all
the threads currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
when the time as reported by boost::get_system_time()
would be equal to or later than
the specified abs_time
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
false
if the call
is returning because the time specified by abs_time
was reached, true
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
timed_wait
in all
the threads currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
after the period of time indicated by the rel_time
argument has elapsed, or spuriously. When the thread is unblocked
(for whatever reason), the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also reacquired by invoking lock.lock()
if the function exits with an exception.
false
if the call
is returning because the time period specified by rel_time
has elapsed, true
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
Note | |
---|---|
The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases. |
As-if
while(!pred()) { if(!timed_wait(lock,abs_time)) { return pred(); } } return true;
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
wait_for
or wait_until
in all the threads
currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
when the time as reported by Clock::now()
would be equal to or later than
the specified abs_time
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
cv_status::timeout
if the call is returning
because the time specified by abs_time
was reached, cv_status::no_timeout
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
lock
is locked
by the current thread, and either no other thread is currently
waiting on *this
,
or the execution of the mutex()
member function on the lock
objects supplied in the
calls to wait
or
wait_until
or
wait_for
in all
the threads currently waiting on *this
would return the same value
as lock->mutex()
for this call to wait
.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
after the period of time indicated by the rel_time
argument has elapsed, or spuriously. When the thread is unblocked
(for whatever reason), the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also reacquired by invoking lock.lock()
if the function exits with an exception.
cv_status::timeout
if the call is returning
because the time period specified by rel_time
has elapsed, cv_status::no_timeout
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
Note | |
---|---|
The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases. |
As-if
while(!pred()) { if(!wait_until(lock,abs_time)) { return pred(); } } return true;
As-if
return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
condition_variable_any()
~condition_variable_any()
void notify_one()
void notify_all()
template<typename lock_type> void wait(lock_type&
lock)
template<typename lock_type,typename predicate_type>
void wait(lock_type& lock, predicate_type
pred)
template<typename lock_type> bool timed_wait(lock_type&
lock,boost::system_time const& abs_time)
template<typename lock_type,typename duration_type>
bool timed_wait(lock_type& lock,duration_type
const&
rel_time)
template<typename lock_type,typename predicate_type>
bool timed_wait(lock_type& lock, boost::system_time
const&
abs_time,
predicate_type pred)
template <class lock_type, class Clock, class Duration> cv_status
wait_until(lock_type&
lock,
const chrono::time_point<Clock, Duration>& abs_time)
template <class lock_type, class Rep, class Period> cv_status
wait_for(lock_type&
lock,
const chrono::duration<Rep, Period>& rel_time)
template <class lock_type, class Clock, class Duration, class Predicate>
bool wait_until(lock_type& lock, const chrono::time_point<Clock, Duration>&
abs_time,
Predicate pred)
template <class lock_type, class Rep, class Period, class Predicate>
bool wait_for(lock_type& lock, const chrono::duration<Rep, Period>&
rel_time,
Predicate pred)
//#include <boost/thread/condition_variable.hpp> namespace boost { class condition_variable_any { public: condition_variable_any(); ~condition_variable_any(); void notify_one(); void notify_all(); template<typename lock_type> void wait(lock_type& lock); template<typename lock_type,typename predicate_type> void wait(lock_type& lock,predicate_type predicate); template <class lock_type, class Clock, class Duration> cv_status wait_until( lock_type& lock, const chrono::time_point<Clock, Duration>& t); template <class lock_type, class Clock, class Duration, class Predicate> bool wait_until( lock_type& lock, const chrono::time_point<Clock, Duration>& t, Predicate pred); template <class lock_type, class Rep, class Period> cv_status wait_for( lock_type& lock, const chrono::duration<Rep, Period>& d); template <class lock_type, class Rep, class Period, class Predicate> bool wait_for( lock_type& lock, const chrono::duration<Rep, Period>& d, Predicate pred); #if defined BOOST_THREAD_USES_DATETIME template<typename lock_type> bool timed_wait(lock_type& lock,boost::system_time const& abs_time); template<typename lock_type,typename duration_type> bool timed_wait(lock_type& lock,duration_type const& rel_time); template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& lock,boost::system_time const& abs_time,predicate_type predicate); template<typename lock_type,typename duration_type,typename predicate_type> bool timed_wait(lock_type& lock,duration_type const& rel_time,predicate_type predicate); template<typename lock_type> bool timed_wait(lock_type>& lock,boost::xtime const& abs_time); template<typename lock_type,typename predicate_type> bool timed_wait(lock_type& lock,boost::xtime const& abs_time,predicate_type predicate); #endif }; }
Constructs an object of class condition_variable_any
.
boost::thread_resource_error
if an error
occurs.
All threads waiting on *this
have been notified by a call
to notify_one
or
notify_all
(though
the respective calls to wait
or timed_wait
need
not have returned).
Destroys the object.
Nothing.
If any threads are currently blocked waiting
on *this
in a call to wait
or timed_wait
,
unblocks one of those threads.
Nothing.
If any threads are currently blocked waiting
on *this
in a call to wait
or timed_wait
,
unblocks all of those threads.
Nothing.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
As-if
while(!pred()) { wait(lock); }
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
when the time as reported by boost::get_system_time()
would be equal to or later than
the specified abs_time
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
false
if the call
is returning because the time specified by abs_time
was reached, true
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
after the period of time indicated by the rel_time
argument has elapsed, or spuriously. When the thread is unblocked
(for whatever reason), the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also reacquired by invoking lock.lock()
if the function exits with an exception.
false
if the call
is returning because the time period specified by rel_time
has elapsed, true
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
Note | |
---|---|
The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases. |
As-if
while(!pred()) { if(!timed_wait(lock,abs_time)) { return pred(); } } return true;
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
when the time as reported by Clock::now()
would be equal to or later than
the specified abs_time
,
or spuriously. When the thread is unblocked (for whatever reason),
the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also
reacquired by invoking lock.lock()
if the function exits with an
exception.
cv_status::timeout
if the call is returning
because the time specified by abs_time
was reached, cv_status::no_timeout
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
Atomically call lock.unlock()
and blocks the current thread.
The thread will unblock when notified by a call to this->notify_one()
or this->notify_all()
,
after the period of time indicated by the rel_time
argument has elapsed, or spuriously. When the thread is unblocked
(for whatever reason), the lock is reacquired by invoking lock.lock()
before the call to wait
returns. The lock is also reacquired by invoking lock.lock()
if the function exits with an exception.
cv_status::timeout
if the call is returning
because the time specified by abs_time
was reached, cv_status::no_timeout
otherwise.
lock
is locked
by the current thread.
boost::thread_resource_error
if an error
occurs. boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
Note | |
---|---|
The duration overload of timed_wait is difficult to use correctly. The overload taking a predicate should be preferred in most cases. |
As-if
while(!pred())
{
if(!wait_until
(lock,abs_time))
{
return pred();
}
}
return true;
As-if
return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
// #include <boost/thread/condition.hpp> namespace boost { typedef condition_variable_any condition; }
The typedef condition
is
provided for backwards compatibility with previous boost releases.
// #include <boost/thread/condition_variable.hpp> namespace boost { void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); }
lk
is locked by the
calling thread and either no other thread is waiting on cond
, or lk.mutex()
returns the same value for each
of the lock arguments supplied by all concurrently waiting (via
wait
, wait_for
, or wait_until
)
threads.
transfers ownership of the lock associated with lk
into internal storage and schedules cond
to be notified when the current thread exits, after all objects of
thread storage duration associated with the current thread have been
destroyed. This notification shall be as if
lk.unlock(); cond.notify_all();
#include <boost/thread/once.hpp> namespace boost { struct once_flag; template<typename Function, class ...ArgTypes> inline void call_once(once_flag& flag, Function&& f, ArgTypes&&... args); #if defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 void call_once(void (*func)(),once_flag& flag); #endif }
Warning | |
---|---|
the variadic prototype is provided only on C++11 compilers supporting variadic templates, otherwise the interface is limited up to 3 parameters. |
Warning | |
---|---|
the move semantics is ensured only on C++11 compilers supporting SFINAE expression, decltype N3276 and auto. Waiting for a boost::bind that is move aware. |
boost::call_once
provides a mechanism for ensuring
that an initialization routine is run exactly once without data races or
deadlocks.
#ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11 struct once_flag { constexprr once_flag() noexcept; once_flag(const once_flag&) = delete; once_flag& operator=(const once_flag&) = delete; }; #else typedef platform-specific-type once_flag; #define BOOST_ONCE_INIT platform-specific-initializer #endif
Objects of type boost::once_flag
shall be initialized with
BOOST_ONCE_INIT
if BOOST_THREAD_PROVIDES_ONCE_CXX11
is not defined
boost::once_flag f=BOOST_ONCE_INIT;
template<typename Function, class ...ArgTypes> inline void call_once(once_flag& flag, Function&& f, ArgTypes&&... args);
Function
and each
or the ArgTypes
are
MoveConstructible
and invoke(decay_copy(boost::forward<Function>(f)),
decay_copy(boost::forward<ArgTypes>(args))...)
shall be well formed.
Calls to call_once
on the same once_flag
object are serialized. If there has been no prior effective call_once
on the same once_flag
object, the argument
func
is called as-if
by invoking invoke(decay_copy(boost::forward<Function>(f)), decay_copy(boost::forward<ArgTypes>(args))...)
, and the invocation of call_once
is effective if and only
if invoke(decay_copy(boost::forward<Function>(f)),
decay_copy(boost::forward<ArgTypes>(args))...)
returns without exception. If an exception is thrown, the exception
is propagated to the caller. If there has been a prior effective
call_once
on the
same once_flag
object,
the call_once
returns
without invoking func
.
The completion of an effective call_once
invocation on a once_flag
object, synchronizes with all subsequent call_once
invocations on the same once_flag
object.
thread_resource_error
when the effects cannot be achieved or any exception propagated from
func
.
The function passed to call_once
must not also call call_once
passing the same once_flag
object. This may cause deadlock, or invoking the passed function
a second time. The alternative is to allow the second call to return
immediately, but that assumes the code knows it has been called recursively,
and can proceed even though the call to call_once
didn't actually call the function, in which case it could also avoid
calling call_once
recursively.
On some compilers this function has some restrictions, e.g. if variadic templates are not supported the number of arguments is limited to 3; .
void call_once(void (*func)(),once_flag& flag);
This second overload is provided for backwards compatibility and is deprecated.
The effects of call_once(func,flag)
shall be the same as those of call_once(flag,func)
.
A barrier is a simple concept. Also known as a rendezvous,
it is a synchronization point between multiple threads. The barrier is configured
for a particular number of threads (n
),
and as threads reach the barrier they must wait until all n
threads have arrived. Once the n
-th
thread has reached the barrier, all the waiting threads can proceed, and
the barrier is reset.
#include <boost/thread/barrier.hpp> class barrier { public: barrier(barrier const&) = delete; barrier& operator=(barrier const&) = delete; barrier(unsigned int count); template <typename F> barrier(unsigned int count, F&&); ~barrier(); bool wait(); void count_down_and_wait(); };
Instances of boost::barrier
are not copyable or movable.
barrier(unsigned int count);
Construct a barrier for count
threads.
boost::thread_resource_error
if an error
occurs.
barrier(unsigned int count, F&& completion);
The result type of the completion function call completion()
is void
or unsigned int
.
Construct a barrier for count
threads and a completion function completion
.
boost::thread_resource_error
if an error
occurs.
~barrier();
No threads are waiting on *this
.
Destroys *this
.
Nothing.
bool wait();
Block until count
threads have called wait
or count_down_and_wait
on *this
.
When the count
-th
thread calls wait
,
the barrier is reset and all waiting threads are unblocked. The
reset depends on whether the barrier was constructed with a completion
function or not. If there is no completion function or if the completion
function result is void, the reset consists in restoring the original
count. Otherwise the rest consist in assigning the result of the
completion function (which must not be 0).
true
for exactly one
thread from each batch of waiting threads, false
otherwise.
- boost::thread_resource_error
if an error
occurs.
- boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
wait()
is an interruption point.
void count_down_and_wait();
Block until count
threads have called wait
or count_down_and_wait
on *this
.
When the count
-th
thread calls wait
,
the barrier is reset and all waiting threads are unblocked. The
reset depends on whether the barrier was constructed with a completion
function or not. If there is no completion function or if the completion
function result is void, the reset consists in restoring the original
count. Otherwise the rest consist in assigning the result of the
completion function (which must not be 0).
- boost::thread_resource_error
if an error
occurs.
- boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
count_down_and_wait()
is an interruption
point.
Latches are a thread co-ordination mechanism that allow one or more threads to block until one or more threads have reached a point.
Sample use cases for the latch include:
An example of the first use case would be as follows:
void DoWork(thread_pool* pool) { latch completion_latch(NTASKS); for (int i = 0; i < NTASKS; ++i) { pool->submit([&] { // perform work ... completion_latch.count_down(); })); } // Block until work is done completion_latch.wait(); }
An example of the second use case is shown below. We need to load data and then process it using a number of threads. Loading the data is I/O bound, whereas starting threads and creating data structures is CPU bound. By running these in parallel, throughput can be increased.
void DoWork() { latch start_latch(1); vector<thread*> workers; for (int i = 0; i < NTHREADS; ++i) { workers.push_back(new thread([&] { // Initialize data structures. This is CPU bound. ... start_latch.wait(); // perform work ... })); } // Load input data. This is I/O bound. ... // Threads can now start processing start_latch.count_down(); }
#include <boost/thread/latch.hpp> class latch { public: latch(latch const&) = delete; latch& operator=(latch const&) = delete; latch(std::size_t count); ~latch(); void wait(); bool try_wait(); template <class Rep, class Period> cv_status wait_for(const chrono::duration<Rep, Period>& rel_time); template <class lock_type, class Clock, class Duration> cv_status wait_until(const chrono::time_point<Clock, Duration>& abs_time); void count_down(); void count_down_and_wait(); };
A latch maintains an internal counter that is initialized when the latch is created. One or more threads may block waiting until the counter is decremented to 0.
Instances of latch
are not copyable or movable.
latch(std::size_t count);
Construct a latch with is initial value for the internal counter.
The counter could be zero.
Nothing.
~latch();
No threads are waiting or invoking count_down on *this
.
Destroys *this
latch.
Nothing.
void wait();
Block the calling thread until the internal count reaches the value zero. Then all waiting threads are unblocked.
- boost::thread_resource_error
if an error
occurs.
- boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
wait()
is an interruption point.
bool try_wait();
Returns true if the internal count is 0, and false otherwise. Does not block the calling thread.
- boost::thread_resource_error
if an error
occurs.
template <class Rep, class Period> cv_status wait_for(const chrono::duration<Rep, Period>& rel_time);
Block the calling thread until the internal count reaches the value zero or the duration has been elapsed. If no timeout, all waiting threads are unblocked.
cv_status::no_timeout if the internal count is 0, and cv_status::timeout if duration has been elapsed.
- boost::thread_resource_error
if an error
occurs.
- boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
wait_for()
is an interruption point.
template <class lock_type, class Clock, class Duration> cv_status wait_until(const chrono::time_point<Clock, Duration>& abs_time);
Block the calling thread until the internal count reaches the value zero or the time_point has been reached. If no timeout, all waiting threads are unblocked.
cv_status::no_timeout if the internal count is 0, and cv_status::timeout if time_point has been reached.
- boost::thread_resource_error
if an error
occurs.
- boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
wait_until()
is an interruption point.
void count_down();
The internal counter is non zero.
Decrements the internal count by 1, and returns. If the count reaches 0, any threads blocked in wait() will be released.
- boost::thread_resource_error
if an error
occurs.
- boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
count_down()
is an interruption point.
void count_down_and_wait();
The internal counter is non zero.
Decrements the internal count by 1. If the resulting count is not 0, blocks the calling thread until the internal count is decremented to 0 by one or more other threads calling count_down() or count_down_and_wait().
- boost::thread_resource_error
if an error
occurs.
- boost::thread_interrupted
if the wait
was interrupted by a call to interrupt()
on the boost::thread
object associated
with the current thread of execution.
count_down_and_wait()
is an interruption
point.
[
reset( size_t );
This function may only be invoked when there are no other threads currently inside the waiting functions.
Resets the latch with a new value for the initial thread count.
- boost::thread_resource_error
if an error
occurs.
]
Warning | |
---|---|
These features are experimental and subject to change in future versions. There are not too much tests yet, so it is possible that you can find out some trivial bugs :( |
Note | |
---|---|
These features are based on the N3785 - Executors and Schedulers revision 3 C++1y proposal from Chris Mysen, Niklas Gustafsson, Matt Austern, Jeffrey Yasskin. The text that follows has been adapted from tis paper to show the differences. |
Executors are objects that can execute units of work packaged as function objects. Boost.Thread differs from N3785 mainly in the an Executor doesn't needs to inherit from an abstract class Executor. Static polymorphism is used instead and type erasure is used internally.
Multithreaded programs often involve discrete (sometimes small) units of work that are executed asynchronously. This often involves passing work units to some component that manages execution. We already have boost::async, which potentially executes a function asynchronously and eventually returns its result in a future. (“As if” by launching a new thread.)
If there is a regular stream of small work items then we almost certainly don’t want to launch a new thread for each, and it’s likely that we want at least some control over which thread(s) execute which items. It is often convenient to represent that control as multiple executor objects. This allows programs to start executors when necessary, switch from one executor to another to control execution policy, and use multiple executors to prevent interference and thread exhaustion. Several possible implementations exist of the executor class and in practice there are a number of main groups of executors which have been found to be useful in real-world code (more implementations exist, this is simply a high level classification of them). These differ along a couple main dimensions, how many execution contexts will be used, how they are selected, and how they are prioritized.
A question arises of which of these executors (or others) be included in
this library. There are use cases for these and many other executors. Often
it is useful to have more than one implemented executor (e.g. the thread
pool) to have more precise control of where the work is executed due to
the existence of a GUI thread, or for testing purposes. A few core executors
are frequently useful and these have been outlined here as the core of
what should be in this library, if common use cases arise for alternative
executor implementations, they can be added in the future. The current
set provided here are: a basic thread pool basic_thread_pool
,
a serial executor serial_executor
,
a loop executor loop_executor
,
an inline executor inline_executor
and a thread-spawning executor thread_executor
.
#include <boost/thread/executors/basic_thread_pool.hpp> #include <boost/thread/future.hpp> #include <numeric> #include <algorithm> #include <functional> #include <iostream> #include <list> template<typename T> struct sorter { boost::basic_thread_pool pool; typedef std::list<T> return_type; std::list<T> do_sort(std::list<T> chunk_data) { if(chunk_data.empty()) { return chunk_data; } std::list<T> result; result.splice(result.begin(),chunk_data, chunk_data.begin()); T const& partition_val=*result.begin(); typename std::list<T>::iterator divide_point = std::partition(chunk_data.begin(), chunk_data.end(), [&](T const& val){return val<partition_val;}); std::list<T> new_lower_chunk; new_lower_chunk.splice(new_lower_chunk.end(), chunk_data, chunk_data.begin(), divide_point); boost::future<std::list<T> > new_lower = boost::async(pool, &sorter::do_sort, this, std::move(new_lower_chunk)); std::list<T> new_higher(do_sort(chunk_data)); result.splice(result.end(),new_higher); while(!new_lower.is_ready()) { pool.schedule_one_or_yield(); } result.splice(result.begin(),new_lower.get()); return result; } }; template<typename T> std::list<T> parallel_quick_sort(std::list<T>& input) { if(input.empty()) { return input; } sorter<T> s; return s.do_sort(input); }
The authors of Boost.Thread have taken a different approach respect to N3785. Instead of basing all the design on a abstract executor class we make executor concepts. We believe that this is the good direction as a static polymorphic executor can be seen as a dynamic polymorphic executor using a simple adaptor. We believe also that it would make the library more usable, and more convenient for users.
The major design decisions concern deciding what a unit of work is, how to manage with units of work and time related functions in a polymorphic way.
An Executor is an object that schedules the closures that have been submitted to it, usually asynchronously. There could be multiple models of the Executor class. Some specific design notes:
One important question is just what a closure is. This library has a very
simple answer: a closure is a Callable
with no parameters and returning void
.
N3785 choose the more specific std::function<void()>
as it provides only dynamic polymorphism
and states that in practice the implementation of a template based approach
or another approach is impractical. The authors of this library think that
the template based approach is compatible with a dynamic based approach.
They give some arguments:
The first one is that a virtual function can not be a template. This is
true but it is also true that the executor interface can provide the template
functions that call to the virtual public functions. Another reason they
give is that "a template parameter would complicate the interface
without adding any real generality. In the end an executor class is going
to need some kind of type erasure to handle all the different kinds of
function objects with void()
signature, and that’s exactly what
std::function already does". We think that it is up to the executor
to manage with this implementation details, not to the user.
We share all the argument they give related to the void()
interface of the work unit. A work unit
is a closure that takes no arguments and returns no value. This is indeed
a limitation on user code, but combined with boost::async
taking executors as parameters the user has all what she needs.
The third one is related to performance. They assert that "any mechanism
for storing closures on an executor’s queue will have to use some form
of type erasure. There’s no reason to believe that a custom closure mechanism,
written just for std::executor and used nowhere else within the standard
library, would be better in that respect than std::function<void()>
". We believe that the implementation
can do better that storing the closure on a std::function<void()>
. e.g. the implementation can use
intrusive data to store the closure and the pointers to other nodes needed
to store the closures in a given order.
In addition std::function<void()>
can not be constructed by moving the closure, so e.g. std::packaged_task
could not be a Closure.
As in N3785 and based on the same design decision than std
/boost::thread
if a user closure throws an exception,
the executor must call the std::terminate
function. Note that when we combine boost::async
and Executors
, the exception
will be caught by the closure associated to the returned future, so that
the exception is stored on the returned future, as for the other async
overloads.
It is common idiom to set some thread local variable at the beginning of a thread. As Executors could instantiate threads internally these Executors shall have the ability to call a user specific function at thread entry on the executor constructor.
For executors that don't instantiate any thread and that would use the
current thread this function shall be called only for the thread calling
the at_thread_entry
member
function.
The library does not provision yet for the ability to cancel/interrupt work, though this is a commonly requested feature.
This could be managed externally by an additional cancelation object that can be shared between the creator of the unit of work and the unit of work.
We can think also of a cancelable closure that could be used in a more transparent way.
An alternative is to make async return a cancelable_task but this will need also a cancelable closure.
The library does not provision for the ability to get the current executor, though having access to it could simplify a lot the user code.
The reason is that the user can always use a thread_local variable and
reset it using the at_thread_entry
member function.
thread_local current_executor_state_type current_executor_state; executor* current_executor() { return current_executor_state.current_executor(); } basic_thread_pool pool( // at_thread_entry [](basic_thread_pool& pool) { current_executor_state.set_current_executor(pool); } );
The library authors share some of the concerns of the C++ standard committee (introduction of a new single shared resource, a singleton, could make it difficult to make it portable to all the environments) and that this library doesn't need to provide a default executor for the time been.
The user can always define his default executor himself and use the at_thread_entry
member function to set
the default constructor.
thread_local default_executor_state_type default_executor_state; executor* default_executor() { return default_executor_state.default_executor(); } // in main MyDefaultExecutor myDefaultExecutor( // at_thread_entry [](MyDefaultExecutor& ex) { default_executor_state.set_default_executor(ex); } ); basic_thread_pool pool( // at_thread_entry [&myDefaultExecutor](basic_thread_pool& pool) { default_executor_state.set_default_executor(myDefaultExecutor); } );
A type E
meets the Closure
requirements if is a model
of Callable(void())
and a model of CopyConstructible
/MoveConstructible
.
The Executor
concept
models the common operations of all the executors.
A type E
meets the Executor
requirements if the following
expressions are well-formed and have the specified semantics
e.submit(lc);
e.submit(rc);
e.close();
b =
e.closed();
e.try_executing_one();
e.reschedule_until(p);
where
e
denotes a value
of type E
,
lc
denotes a lvalue
referece of type Closure
,
rc
denotes a rvalue
referece of type Closure
p
denotes a value
of type Predicate
The specified closure will be scheduled for execution at some point in the future. If invoked closure throws an exception the executor will call std::terminate, as is the case with threads.
completion of closure on a particular thread happens before destruction of thread's thread local variables.
void
.
sync_queue_is_closed if the thread pool is closed. Whatever exception that can be throw while storing the closure.
If an exception is thrown then the executor state is unmodified.
The specified closure will be scheduled for execution at some point in the future. If invoked closure throws an exception the executor will call std::terminate, as is the case with threads.
completion of closure on a particular thread happens before destruction of thread's thread local variables.
void
.
sync_queue_is_closed if the thread pool is closed. Whatever exception that can be throw while storing the closure.
If an exception is thrown then the executor state is unmodified.
close the executor e
for submissions.
The worker threads will work until there is no more closures to run.
void
.
Whatever exception that can be throw while ensuring the thread safety.
If an exception is thrown then the executor state is unmodified.
bool
.
whether the pool is closed for submissions.
Whatever exception that can be throw while ensuring the thread safety.
try to execute one work.
whether a work has been executed.
bool
.
Whether a work has been executed.
whatever the current work constructor throws or the work()
throws.
This must be called from an scheduled work
reschedule works until p()
.
bool
.
Whether a work has been executed.
whatever the current work constructor throws or the work()
throws.
#include <boost/thread/work.hpp> namespace boost { typedef 'implementation_defined' work; }
work is a model of 'Closure'
Executor abstract base class.
#include <boost/thread/executor.hpp> namespace boost { class executor { public: typedef boost::work work; executor(executor const&) = delete; executor& operator=(executor const&) = delete; executor(); virtual ~executor() {}; virtual void close() = 0; virtual bool closed() = 0; virtual void submit(work&& closure) = 0; virtual void submit(work& closure) = 0; template <typename Closure> void submit(Closure&& closure); virtual bool try_executing_one() = 0; template <typename Pred> bool reschedule_until(Pred const& pred); }; }
virtual ~executor();
Destroys the executor.
The completion of all the closures happen before the completion of the executor destructor.
Polymorphic adaptor of a model of Executor to an executor.
#include <boost/thread/executor.hpp> namespace boost { template <typename Executor> class executor_adaptor : public executor { Executor ex; // for exposition only public: typedef executor::work work; executor_adaptor(executor_adaptor const&) = delete; executor_adaptor& operator=(executor_adaptor const&) = delete; template <typename ...Args> executor_adaptor(Args&& ... args); Executor& underlying_executor(); void close(); bool closed(); void submit(work&& closure); void submit(work& closure); bool try_executing_one(); }; }
template <typename ...Args> executor_adaptor(Args&& ... args);
Constructs a executor_adaptor.
Nothing.
virtual ~executor_adaptor();
Destroys the executor_adaptor.
The completion of all the closures happen before the completion of the executor destructor.
Executor& underlying_executor();
The underlying executor instance.
Nothing.
Executor abstract base class.
#include <boost/thread/generic_executor_ref.hpp> namespace boost { class generic_executor_ref { public: generic_executor_ref(generic_executor_ref const&); generic_executor_ref& operator=(generic_executor_ref const&); template <class Executor> executor(Executor& ex); generic_executor_ref() {}; void close() = 0; bool closed() = 0; template <typename Closure> void submit(Closure&& closure); virtual bool try_executing_one() = 0; template <typename Pred> bool reschedule_until(Pred const& pred); }; }
A serial executor ensuring that there are no two work units that executes concurrently.
#include <boost/thread/serial_executor.hpp> namespace boost { class serial_executor { public: serial_executor(serial_executor const&) = delete; serial_executor& operator=(serial_executor const&) = delete; template <class Executor> serial_executor(Executor& ex); generic_executor_ref underlying_executor(); void close(); bool closed(); template <typename Closure> void submit(Closure&& closure); bool try_executing_one(); template <typename Pred> bool reschedule_until(Pred const& pred); }; }
template <class Executor> serial_executor(Executor& ex);
Constructs a serial_executor.
Nothing.
~serial_executor();
Destroys the serial_executor.
The completion of all the closures happen before the completion of the executor destructor.
generic_executor_ref underlying_executor();
The underlying executor instance.
Nothing.
A serial executor ensuring that there are no two work units that executes concurrently.
#include <boost/thread/inline_executor.hpp> namespace boost { class inline_executor { public: inline_executor(inline_executor const&) = delete; inline_executor& operator=(inline_executor const&) = delete; inline_executor(); void close(); bool closed(); template <typename Closure> void submit(Closure&& closure); bool try_executing_one(); template <typename Pred> bool reschedule_until(Pred const& pred); }; }
inline_executor();
Constructs a inline_executor.
Nothing.
~inline_executor();
Destroys the inline_executor.
The completion of all the closures happen before the completion of the executor destructor.
A thread pool with up to a fixed number of threads.
#include <boost/thread/work.hpp> namespace boost { class basic_thread_pool { public: basic_thread_pool(basic_thread_pool const&) = delete; basic_thread_pool& operator=(basic_thread_pool const&) = delete; basic_thread_pool(unsigned const thread_count = thread::hardware_concurrency()); template <class AtThreadEntry> basic_thread_pool( unsigned const thread_count, AtThreadEntry at_thread_entry); ~basic_thread_pool(); void close(); bool closed(); template <typename Closure> void submit(Closure&& closure); bool try_executing_one(); template <typename Pred> bool reschedule_until(Pred const& pred); }; }
creates a thread pool that runs closures on thread_count
threads.
Whatever exception is thrown while initializing the needed resources.
virtual ~basic_thread_pool();
Destroys the thread pool.
The completion of all the closures happen before the completion of the executor destructor.
A user scheduled executor.
#include <boost/thread/loop_executor.hpp> namespace boost { class loop_executor { public: loop_executor(loop_executor const&) = delete; loop_executor& operator=(loop_executor const&) = delete; loop_executor(); ~loop_executor(); void close(); bool closed(); template <typename Closure> void submit(Closure&& closure); bool try_executing_one(); template <typename Pred> bool reschedule_until(Pred const& pred); void loop(); void run_queued_closures(); }; }
loop_executor();
creates a executor that runs closures using one of its closure-executing methods.
Whatever exception is thrown while initializing the needed resources.
virtual ~loop_executor();
Destroys the executor.
The completion of all the closures happen before the completion of the executor destructor. <