Custom conditional scoped mutex lock

Question

I am making a custom Conditional Scoped Mutex Lock.

I have this class defined in my header:

class ConditionalLock
{
public:
    ConditionalLock(eastl::function<bool()> condition);
    ~ConditionalLock();

private:        
    static std::mutex s_mtx;
    static bool s_shouldLock;
    static bool s_lockInit;
};

.cpp looks like this:

ConditionalLock::ConditionalLock(std::function<bool()> condition)
{
    if (!s_lockInit)
    {
        if (condition())
            s_shouldLock = true;

        s_lockInit = true;
    }

    if (s_shouldLock)
        s_mtx.Lock();
}

ConditionalLock::~ConditionalLock()
{
    if (s_shouldLock)
        s_mtx.Unlock();
}

This conditional lock does the trick if I use it in only one place, concerning the fact that it contains three static members that track everything I need. However, I want to have a generic conditioned mutex that could be reused everywhere. What would be the right approach?

I thought about making a ConditionalMutexContext class that would be instantiated in the scope of the object where I want to use this mutex, and that config would contain these properties.

Something like this:

class ConditionalLockContext 
{
public:
    ConditionalLockContext(
        std::function<bool()> condition)
    : m_condition(condition)

private: 
    std::function<bool()> m_condition;
    bool m_shouldLock;
    bool m_lockInit;
}

And then pass the ConditionalLockContext instance to the conditional lock by reference.

Could you think of a better approach for this specific scenario?

Answer 1

You are confusing mutexes with locks. In C++, we implement RAII locking via (scoped) locks, mutexes do not have this behavior; look at std::mutex.

You want to implement a conditional scoped lock (derive from std::unique_lock, perhaps?). The state whether it locked something is separated from the state of the mutex.

In any case, I do not see a reason of having a shared state between all mutex instances, because that is exactly what static means... On the other hand, a mutex should be shared by lock instances, but not all of them. Thus, you want locks to refer to mutexes.

If you do not want to derive from std::unique_lock (private-ly, of course), remove all static specifiers, and change the member mutex so that it is a reference that is provided during the construction of the lock.