How to fix the problem when a mutex is a local…

The problem is that a local mutex created in one function is destroyed when exiting or returning from that function. If it is used to synchronize access to shared resources in other threads that continue to operate, then after the mutex is destroyed, synchronization is broken, leading to a race condition and undefined behavior.

To fix this issue, the mutex should exist in a scope accessible to all threads working with the protected resource.

Possible solutions:

Global mutex: If the resource is used in different parts of the program, you can declare the mutex as a global variable.

// global mutex
std::mutex global_mutex;

void access_shared_resource() {
    // lock the mutex before access
    std::lock_guard<std::mutex> lock(global_mutex);
    // access to shared resource...
    // mutex automatically unlocks when leaving scope
}

Class member (to protect class data): If the resource is a class member, the mutex can also be a member of that class.

class SharedData {
public:
    void access_data() {
        // lock the mutex
        std::lock_guard<std::mutex> lock(mutex_);
        // access to data_...
    }
private:
    std::mutex mutex_; // class member mutex
    //... class data (resource)
};

Static class member (to protect static class data): If the resource is a static class member.

class SharedStaticData {
public:
    static void access_static_data() {
        // lock the static mutex
        std::lock_guard<std::mutex> lock(static_mutex_);
        // access to static_data_...
    }
private:
    static std::mutex static_mutex_; // static mutex
    //... static class data (resource)
};

// definition of static member
std::mutex SharedStaticData::static_mutex_;

Heap (dynamic allocation): Less preferred option, requiring explicit lifecycle management. The mutex is allocated on the heap and passed between threads (e.g., via a pointer).
```
// Bad example, requires careful lifecycle control
std::mutex* shared_mutex = new std::mutex();

void thread_func() {
    // unsafe without guarantees that mutex is not deleted by another thread
    std::lock_guard<std::mutex> lock(*shared_mutex);
    // ...
}

//... need to delete shared_mutex at the end of work
// delete shared_mutex; // dangerous without synchronization of deletion
```
This approach is not recommended due to the complexity of lifecycle management and risks of leaks or using a deleted mutex. Prefer solutions with automatic lifecycle management (stack, class members, global variables), where the mutex lives longer than the functions that use it.

The main point is to ensure that the mutex exists as long as the resource it protects exists, and as long as any thread might attempt to access that resource.

How to fix the problem when a mutex is a local variable?