Deferlock

Defer_lock (often written with an underscore as defer_lock) refers to a tag type in the C++ standard library that indicates a mutex should not be locked when a lock object is constructed. It is exposed as the constant std::defer_lock of type defer_lock_t and is used to control when locking actually occurs.

The primary purpose of defer_lock is to give the programmer manual control over the locking operation. It enables building a lock object without acquiring the mutex immediately, which is useful when the lock must be obtained in a specific sequence or after some other setup has occurred. The most common use is with std::unique_lock, which supports a constructor that takes a mutex and a defer_lock tag to create an unlocked lock.

Example usage: std::mutex m; std::unique_lock<std::mutex> ul(m, std::defer_lock); // not locked yet ul.lock(); // lock when ready

In addition to defer_lock, there are related tagging options for std::unique_lock: std::try_to_lock attempts to lock during construction, and std::adopt_lock transfers ownership of a mutex that is already locked by the current thread. Note that std::lock_guard does not provide a defer option and will lock the mutex upon construction.

Overview and compatibility: Defer_lock is part of the C++ standard library since C++11 and is widely supported by major implementations. It is primarily used to enable flexible lock acquisition patterns and to coordinate multiple locks safely.

See also: std::defer_lock_t, std::unique_lock, std::lock_guard, std::mutex, std::try_to_lock, std::adopt_lock.

---