Shulou(Shulou.com)05/31 Report--

Most people do not understand the knowledge points of this article "how to use Lock to achieve concurrency", so the editor summarizes the following contents, detailed contents, clear steps, and has a certain reference value. I hope you can get something after reading this article. Let's take a look at this article "how to use Lock to achieve concurrency in Craft 11" article.

The Category 11 standard provides us with two basic lock types, one of which is as follows:

Std::lock_guard, related to Mutex RAII, makes it easy for threads to lock mutexes.

Std::unique_lock, related to Mutex RAII, makes it easy for threads to lock mutexes, but provides better locking and unlocking control.

There are also several Tag classes related to lock types, which are as follows:

Std::adopt_lock_t, an empty tag class, is defined as follows:

Struct adopt_lock_t {}

This type of constant object adopt_lock (adopt_lock is a constant object, defined as follows:

Constexpr adopt_lock_t adopt_lock {}; / / constexpr is a new keyword in Clippers 11)

It is usually passed as an argument to the constructor of unique_lock or lock_guard.

Std::defer_lock_t, an empty tag class, is defined as follows:

Struct defer_lock_t {}

This type of constant object defer_lock (defer_lock is a constant object, defined as follows:

Constexpr defer_lock_t defer_lock {}; / / constexpr is a new keyword in Clippers 11)

It is usually passed as an argument to the constructor of unique_lock or lock_guard.

Std::try_to_lock_t, an empty tag class, is defined as follows:

Struct try_to_lock_t {}

This type of constant object try_to_lock (try_to_lock is a constant object, defined as follows:

Constexpr try_to_lock_t try_to_lock {}; / / constexpr is a new keyword in Clippers 11)

It is usually passed as an argument to the constructor of unique_lock or lock_guard. Later, we will describe in detail the differences between the above three Tag types when used with lock_gurad and unique_lock.

Std::lock_guard introduction

Std::lock_gurad is a template class defined in Clippers 11. The definition is as follows:

Template class lock_guard

Lock_guard object is usually used to manage a Lock object, so it is related to Mutex RAII, so it is convenient for threads to lock mutexes, that is, during the declaration cycle of a lock_guard object, the lock object it manages will always remain locked; and after the end of the life cycle of lock_guard, the lock object it manages will be unlocked (Note: smart pointers such as shared_ptr manage dynamically allocated memory resources).

The template parameter Mutex represents the mutex type, such as the std::mutex type, which should be a basic BasicLockable type. Several basic BasicLockable types are defined in the standard library, namely std::mutex, std::recursive_mutex, std::timed_mutex,std::recursive_timed_mutex (all four types have been introduced in the previous blog) and std::unique_lock (std::unique_lock will be introduced later in this article). (note: objects of BasicLockable type only need to satisfy two operations, lock and unlock, and there are also Lockable types. Try_lock operation is added to BasicLockable type, so an object that satisfies Lockable should support three operations: lock,unlock and try_lock. Finally, there is a TimedLockable object, which adds try_lock_for and try_lock_until operations to the Lockable type, so an object that satisfies TimedLockable should support five operations: lock, unlock, try_lock, try_lock_for, try_lock_until).

When the lock_guard object is constructed, the incoming Mutex object (that is, the Mutex object it manages) is locked by the current thread. When the lock_guard object is destructed, the Mutex object it manages will be unlocked automatically, because it does not require programmers to manually call lock and unlock to lock and unlock Mutex, so this is also the simplest and most secure way to lock and unlock, especially after the program throws an exception, the previously locked Mutex object can be unlocked correctly, which greatly simplifies programmers to write exception handling code related to Mutex.

It is worth noting that the lock_guard object is not responsible for managing the life cycle of the Mutex object, the lock_guard object just simplifies the locking and unlocking operation of the Mutex object, making it convenient for the thread to lock the mutex, that is, during the declaration cycle of a lock_guard object, the locked object it manages will remain locked; and after the end of the life cycle of the lock_guard, the locked object it manages will be unlocked.

Std::lock_guard constructor

The lock_guard constructor is shown in the following table:

Locking (1) explicit lock_guard (mutex_type& m); adopting (2) lock_guard (mutex_type& m, adopt_lock_t tag); copy [deleted] (3) lock_guard (const lock_guard&) = delete

Locking initialization

The lock_guard object manages the Mutex object m and locks m at construction time (calling m.lock ()).

Adopting initialization

The lock_guard object manages the Mutex object m, and unlike locking initialization (1), the Mutex object m is locked by the current thread.

Copy construction

Both copy construction and mobile construction (move construction) of lock_guard objects are disabled, so lock_guard objects cannot be copied or moved.

Let's look at a simple example (reference):

# include / / std::cout#include / / std::thread#include / / std::mutex, std::lock_guard, std::adopt_lockstd::mutex mtx; / / mutex for critical sectionvoid print_thread_id (int id) {mtx.lock (); std::lock_guard lck (mtx, std::adopt_lock); std::cout

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.