What happens if you call the lock method multiple…

Calling the lock method on the same mutex object (for example, std::mutex or std::recursive_mutex) from the same thread will lead to the following:

For std::mutex: A deadlock will occur. The thread that already owns the mutex will try to lock it again but will not succeed because it is already locked by the same thread.
For std::recursive_mutex: The lock will be successful. std::recursive_mutex keeps track of how many times it has been locked by the current thread. The thread will acquire the mutex, and the recursive lock counter will be incremented. To fully unlock the mutex, unlock must be called as many times as lock was successfully called.

Calling the lock method on a mutex from different threads is a standard synchronization mechanism. The thread that calls lock will be blocked (paused) until the thread owning the mutex calls unlock.

Example with std::mutex (leads to deadlock from the same thread):

#include <mutex>
#include <iostream>

std::mutex my_mutex;

void deadlock_example() {
    my_mutex.lock(); // First successful lock
    std::cout << "Mutex locked once.\n";
    // This call will lead to deadlock if from the same thread:
    my_mutex.lock(); // Attempt to lock the mutex already owned by this thread
    std::cout << "Mutex locked twice.\n"; // This line will not be reached
    my_mutex.unlock();
    my_mutex.unlock();
}

int main() {
    deadlock_example(); // Will only execute up to the second my_mutex.lock()
    return 0;
}

Example with std::recursive_mutex:

#include <mutex>
#include <iostream>

std::recursive_mutex my_recursive_mutex;

void recursive_lock_example() {
    my_recursive_mutex.lock(); // First lock
    std::cout << "Recursive mutex locked once.\n";

    my_recursive_mutex.lock(); // Second lock by the same thread
    std::cout << "Recursive mutex locked twice.\n";

    my_recursive_mutex.unlock(); // Unlock level 1
    std::cout << "Recursive mutex unlocked once.\n";

    my_recursive_mutex.unlock(); // Unlock level 2
    std::cout << "Recursive mutex unlocked twice.\n";
}

int main() {
    recursive_lock_example(); // All steps will be executed
    return 0;
}

What happens if you call the lock method multiple times?