std::mutex

std::mutex is a class defined in the <mutex> header of the C++ standard library, serving as a fundamental tool for multithreaded synchronization. Its primary purpose is to protect shared resources by preventing concurrent acccess from multiple threads, thereby avoiding data races.

std::mutex represents a mutex with two key operations:

1. Locking: Acquire the mutex by calling lock(). If the mutex is currently unlocked, the calling thread obtains it; otherwise, the thread blocks until the mutex becomes available.

std::mutex resource_mutex;
resource_mutex.lock();
// Access or modify protected resource here
resource_mutex.unlock();

2. Unlocking: Release the mutex by calling unlock(), allowing other waiting threads to acquire it and proceed.

resource_mutex.unlock();

Additionally, std::mutex provides utilities like try_lock() for non-blocking lock attempts and RAII-based helpers such as lock_guard and unique_lock for safer lock management.

std::lock_guard

std::lock_guard is a class in the <mutex> header that manages mutex lifetime following the RAII principle. It ensures automatic locking upon entering a scope and automatic unlocking upon exit, preventing issues like forgotten unlocks or exception safety problems.

Typical usage:

#include <mutex>

std::mutex data_mutex;

void protected_operation() {
    std::lock_guard<std::mutex> lock(data_mutex); // Locks automatically
    // Exclusive access to shared resource within this scope
    // Code to access/modify shared resource...
} // Automatically unlocks when lock goes out of scope

In this example, the constructor of std::lock_guard locks data_mutex immediately, and the destructor unlocks it when protected_operation ends, ensuring proper resource release.

std::unique_lock

std::unique_lock is a class for managing mutex locking and unlocking operations, adhering to RAII principles. It ensures mutexes are locked and unlocked appropriately, maintaining safety even during exceptions.

Key features and usage:

1. Constructors:
   • Default constructor creates an object not associated with any mutex.
   • Constructor with a mutex argument attempts immediate locking.
   • Additional flags like defer_lock or try_to_lock allow deferred or non-blocking locking attempts.

std::mutex shared_mutex;
std::unique_lock<std::mutex> lock(shared_mutex); // Direct lock
std::unique_lock<std::mutex> deferred(shared_mutex, std::defer_lock); // Deferred lock
std::unique_lock<std::mutex> trylock(shared_mutex, std::try_to_lock); // Non-blocking attempt

2. Methods:

   • lock(): Locks the mutex, blocking if already locked.
   • unlock(): Unlocks the mutex.
   • try_lock(): Attempts non-blocking lock, returning true on success.
   • owns_lock(): Checks if the lock currently holds the mutex.

3. RAII Behavior: Automatically unlocks the mutex when the object goes out of scope if still locked.

4. Ownership Transfer: Allows transferring lock ownership between std::unique_lock objects.

Example:

std::mutex guard_mutex;
{
    std::unique_lock<std::mutex> lock(guard_mutex);
    // Mutex locked within this scope
    // Access/modify shared resource...
} // Automatic unlock on scope exit

// Using try_lock and manual unlock
std::unique_lock<std::mutex> ul(guard_mutex, std::try_to_lock);
if (ul.owns_lock()) {
    // Successfully locked, perform operations...
} else {
    // Lock failed, handle accordingly...
}
ul.unlock(); // Manual unlock

std::unique_lock provides a secure and convenient way to handle mutex operations in multithreaded environments.

Avoiding Deadlocks with std::lock

std::lock is a function that locks multiple mutexes simultaneously in a deadlock-free manner. It's useful for scenarios requiring protection of multiple resources.

General usage:

#include <mutex>
#include <vector>

std::mutex mutex_a, mutex_b, mutex_c;

void safe_concurrent_access() {
    std::vector<std::unique_lock<std::mutex>> lock_holders;
    lock_holders.reserve(3);

    // Lock all mutexes atomically
    std::lock(mutex_a, mutex_b, mutex_c);

    // Adopt already-locked mutexes for automatic management
    lock_holders.emplace_back(mutex_a, std::adopt_lock);
    lock_holders.emplace_back(mutex_b, std::adopt_lock);
    lock_holders.emplace_back(mutex_c, std::adopt_lock);

    // All mutexes locked, safe resource access...
} // Automatic unlock via unique_lock destructors

std::lock attempts to lock all mutexes in an optimized order, blocking until all can be acquired. It prevents deadlocks by ensuring consistent locking sequences. Typically used with std::unique_lock and std::adopt_lock for automatic unlock management.

Single Initialization with std::once_flag

std::once_flag is a class in <mutex> for thread-safe single initialization (lazy initialization). It ensures initialization code executes only once across multiple threads when used with std::call_once.

Basic usage:

#include <mutex>
#include <thread>

std::once_flag initialization_flag;

void initialize_resource() {
    // Initialization logic, executed only once
    // ...
}

void thread_safe_initializer() {
    std::call_once(initialization_flag, initialize_resource);
}

int main() {
    std::thread t1(thread_safe_initializer);
    std::thread t2(thread_safe_initializer);

    t1.join();
    t2.join();

    // Additional threads calling thread_safe_initializer won't re-execute initialize_resource
    return 0;
}

This mechanism guarantees that initialize_resource runs exactly once, regardless of how many threads invoke thread_safe_initializer.

Read-Write Locks

std::shared_mutex

Intrdouced in C++14, std::shared_mutex implements read-write lock functionality:

• Multiple threads can simultaneously acquire shared locks for reading.
• Only one thread can hold an exclusive lock for writing, blocking other threads during writes.

This balances data consistency with concurrency, especially beneficial for read-intensive operations.

std::shared_lock

std::shared_lock manages the shared (read) lock portion of a read-write mutex, allowing concurrent read access while preventing writes.

Example:

#include <shared_mutex>
#include <iostream>
#include <thread>

std::shared_mutex rw_mutex;
int shared_value = 0;

void read_operation() {
    std::shared_lock<std::shared_mutex> read_lock(rw_mutex);
    std::cout << "Reader: " << shared_value << '\n';
}

void write_operation() {
    std::unique_lock<std::shared_mutex> write_lock(rw_mutex);
    ++shared_value;
    std::cout << "Writer: Updated to " << shared_value << '\n';
}

int main() {
    std::thread reader1(read_operation);
    std::thread reader2(read_operation);

    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::thread writer(write_operation);

    reader1.join();
    reader2.join();
    writer.join();
    return 0;
}

This demonstrates how multiple readers can access shared_value concurrently, while writers require exclusive access.