Verrouillage de mutex conditionnel personnalisé

Question

Je suis en train de créer un verrou Mutex conditionnel à portée variable.

J'ai cette classe définie dans mon en-tête :

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

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

.cpp ressemble à ceci :

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();
}

Ce verrou conditionnel fait l'affaire si je l'utilise à un seul endroit, compte tenu du fait qu'il contient trois membres statiques qui suivent tout ce dont j'ai besoin. Cependant, je veux avoir un mutex conditionné générique qui pourrait être réutilisé partout. Quelle serait la bonne approche ?

J'ai pensé à créer une classe ConditionalMutexContext qui serait instanciée dans la portée de l'objet où je veux utiliser ce mutex, et cette configuration contiendrait ces propriétés.

Quelque chose comme ça :

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

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

Et ensuite, passer l'instance de ConditionalLockContext au verrou conditionnel par référence.

Pouvez-vous imaginer une meilleure approche pour ce scénario spécifique ?

Answer 1

Vous confondez les mutex avec les verrous. En C++, nous mettons en œuvre le verrouillage RAII par le biais de verrous (scopés), les mutex n'ont pas ce comportement. std::mutex .

Vous voulez mettre en œuvre un verrou conditionnel scoped (dérivé de std::unique_lock peut-être ?). L'état de verrouillage de quelque chose est séparé de l'état du mutex.

En tout cas, je ne vois pas la raison d'avoir un état partagé entre tous instances de mutex, car c'est exactement ce que les static signifie... D'un autre côté, un mutex devrait être partagé par les instances de verrouillage, mais no tous. Ainsi, vous voulez que les serrures se référer à aux mutex.

Si vous ne voulez pas dériver de std::unique_lock ( private -bien sûr), supprimer tout static prescripteurs et changez le mutex membre pour qu'il soit un référence qui est fournie pendant la construction de l'écluse.