shared_recursive_mutex.h

Go to the documentation of this file.

//
// Created by Louis Grignon on 06/02/2025.
//
 
#ifndef SHARED_RECURSIVE_MUTEX_H
#define SHARED_RECURSIVE_MUTEX_H
#include <shared_mutex>
 
namespace conscience_utils::mutexutils {
    //the template parameter is needed to be able to define multiple instances of the shared_recursive_mutex
    //since the implementation relies upon thread local storage we need a unique type per lock that is needed
    //is doesn't matter what the input type is, along as it's unique (that's why it's called PhantomType)
    template<typename PhantomType>
    class shared_recursive_mutex_t {
    public:
        shared_recursive_mutex_t(const shared_recursive_mutex_t&) = delete;
        shared_recursive_mutex_t& operator =(const shared_recursive_mutex_t&) = delete;
        static shared_recursive_mutex_t& instance()
        {
            static shared_recursive_mutex_t instance;
            return instance;
        }
 
        void lock();
 
        void lock_shared();
 
        void unlock();
 
        void unlock_shared();
        [[nodiscard]] bool try_lock();
        [[nodiscard]] bool try_lock_shared();
        [[nodiscard]] bool is_locked() const;
        [[nodiscard]]  bool is_locked_shared() const;
 
    private:
        shared_recursive_mutex_t() = default;
 
        std::shared_mutex m_sharedMtx;
        static inline thread_local uint32_t g_readers = 0;
        static inline thread_local uint32_t g_writers = 0;
    };
 
    template<typename PhantomType>
    void shared_recursive_mutex_t<PhantomType>::lock()
    {
        if (g_writers == 0 && g_readers == 0)
        {
            m_sharedMtx.lock();
        }
        else if (g_writers == 0 && g_readers > 0)
        {
            m_sharedMtx.unlock_shared();
            m_sharedMtx.lock();
        }
        ++g_writers;
    }
    template<typename PhantomType>
    void shared_recursive_mutex_t<PhantomType>::lock_shared()
    {
        //if we are locking shared
        if (g_writers > 0)
        {
            ++g_writers;
        }
        else if (g_readers > 0)
        {
            ++g_readers;
        }
        else if (g_readers == 0)
        {
            m_sharedMtx.lock_shared();
            ++g_readers;
        }
    }
    template<typename PhantomType>
    void shared_recursive_mutex_t<PhantomType>::unlock()
    {
        --g_writers;
        if (g_writers > 0)
            return;
        if (g_writers == 0)
        {
            m_sharedMtx.unlock();
            if (g_readers > 0)
                m_sharedMtx.lock_shared();
        }
    }
    template<typename PhantomType>
    void shared_recursive_mutex_t<PhantomType>::unlock_shared()
    {
        //if the g_writers are > 0 it means that when we got the read lock, this thread already has the write lock
        if (g_writers > 0)
        {
            unlock();
            return;
        }
        --g_readers;
        if (g_readers == 0)
        {
            m_sharedMtx.unlock_shared();
        }
    }
    template<typename PhantomType>
    bool shared_recursive_mutex_t<PhantomType>::try_lock()
    {
        //we already have the lock, so we can simply increase the writer count
        if (g_writers > 0)
        {
            ++g_writers;
            return true;
        }
        //we already have a read lock, but we can't aquire the write lock without giving up the read lock
        //so we have to return false here
        if (g_readers > 0)
        {
            return false;
        }
        const bool aquiredLock = m_sharedMtx.try_lock();
        if (aquiredLock)
        {
            ++g_writers;
        }
 
        return aquiredLock;
    }
    template<typename PhantomType>
    bool shared_recursive_mutex_t<PhantomType>::try_lock_shared()
    {
        //we already have the lock, so we can simply increase the lock count
        if (g_writers > 0 || g_readers > 0)
        {
            lock_shared();
            return true;
        }
        const bool aquiredLock = m_sharedMtx.try_lock_shared();
        if (aquiredLock)
        {
            ++g_readers;
        }
        return aquiredLock;
    }
    template<typename PhantomType>
    bool shared_recursive_mutex_t<PhantomType>::is_locked() const
    {
        return g_writers > 0;
    }
    template<typename PhantomType>
    bool shared_recursive_mutex_t<PhantomType>::is_locked_shared() const
    {
        return g_readers > 0 && g_writers == 0;
    }
 
    using shared_recursive_global_mutex = shared_recursive_mutex_t<struct AnonymousType>;
 
}
 
#endif //SHARED_RECURSIVE_MUTEX_H