cThreadLock.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cThreadLock_H
#define _INC_cThreadLock_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNonCopyable.h"
#include "cTimeSys.h"
#include "cInterlockedVal.h"
#include "cOSHandle.h"
#include "cLocker.h"
#include "FileName.h"
 
#if defined(__linux__)
#include <pthread.h>
#endif
 
namespace Gray
{
#ifdef _WIN32
        typedef DWORD           THREADID_t;             
#define _SIZEOF_THREADID 4      // sizeof(THREADID_t)
#elif defined(__linux__)
        typedef pthread_t       THREADID_t;             
#define _SIZEOF_THREADID _SIZEOF_PTR
#else
#error NOOS
#endif
 
#ifdef _WIN32
        typedef DWORD THREAD_EXITCODE_t;        
        static constexpr THREAD_EXITCODE_t THREAD_EXITCODE_RUNNING = ((THREAD_EXITCODE_t)STILL_ACTIVE); 
        static constexpr THREAD_EXITCODE_t THREAD_EXITCODE_ERR = ((THREAD_EXITCODE_t)-1);       
 
#elif defined(__linux__)
        typedef void* THREAD_EXITCODE_t;        
        static constexpr THREAD_EXITCODE_t THREAD_EXITCODE_RUNNING = ((THREAD_EXITCODE_t)2);    
        static constexpr THREAD_EXITCODE_t THREAD_EXITCODE_ERR = ((THREAD_EXITCODE_t)1);        
 
#else
#error NOOS
#endif
 
        static constexpr THREAD_EXITCODE_t THREAD_EXITCODE_OK = ((THREAD_EXITCODE_t)0); 
 
        typedef THREAD_EXITCODE_t(_stdcall* THREAD_FUNC_t)(void*);              // entry point for a thread. same as _WIN32 PTHREAD_START_ROUTINE. like FARPROC ?
 
        class GRAYCORE_LINK cThreadId
        {
 
        protected:
                THREADID_t m_dwThreadId;                
 
        public:
                static const THREADID_t k_NULL = 0;     
 
        public:
                cThreadId(THREADID_t nThreadId = k_NULL) noexcept
                        : m_dwThreadId(nThreadId)
                {
                }
                THREADID_t GetThreadId() const noexcept
                {
                        return m_dwThreadId;
                }
                THREADID_t get_HashCode() const noexcept
                {
                        return m_dwThreadId;
                }
                bool isCurrentThread() const noexcept
                {
                        return IsEqualId(m_dwThreadId, GetCurrentId());
                }
                bool isValidId() const noexcept
                {
                        return IsValidId(m_dwThreadId);
                }
                void InitCurrentId() noexcept
                {
                        m_dwThreadId = GetCurrentId();
                }
 
                static inline THREADID_t GetCurrentId() noexcept
                {
#ifdef _WIN32
                        return ::GetCurrentThreadId();
#else   // __linux__
                        return ::pthread_self();
#endif
                }
                static inline bool IsValidId(THREADID_t id) noexcept
                {
                        return id != cThreadId::k_NULL;
                }
                static inline bool IsEqualId(THREADID_t a, THREADID_t b) noexcept
                {
#ifdef _WIN32
                        return a == b;
#else
                        return ::pthread_equal(a, b);
#endif
                }
                static inline void SleepCurrent(TIMESYS_t uMs = cTimeSys::k_FREQ) noexcept
                {
#ifdef _WIN32
                        ::Sleep(uMs);
#else
                        ::usleep((uMs) * 1000); // Sleep current thread.
#endif
                };
 
                UNITTEST_FRIEND(cThreadLock);
        };
 
        class GRAYCORE_LINK cThreadState
        {
 
        protected:
                bool m_bThreadRunning;          
                VOLATILE bool m_bThreadStopping;                
 
        public:
                cThreadState() noexcept
                        : m_bThreadRunning(false)
                        , m_bThreadStopping(false)
                {
                }
 
                bool isThreadRunning() const noexcept
                {
                        return m_bThreadRunning;
                }
                bool isThreadStopping() const noexcept
                {
                        return m_bThreadStopping;
                }
 
                virtual bool RequestStopThread(bool bWillWait = false) noexcept
                {
                        UNREFERENCED_PARAMETER(bWillWait);
                        m_bThreadStopping = true;
                        return isThreadRunning();
                }
        };
 
        class GRAYCORE_LINK cThreadLockBase : public cLockableBase, protected cNonCopyable
        {
 
        protected:
                THREADID_t __DECL_ALIGN(_SIZEOF_THREADID) m_nLockThreadID;      
        public:
                cThreadLockBase() noexcept
                        : m_nLockThreadID(cThreadId::k_NULL)
                {
                }
                inline bool isLocked() const noexcept
                {
                        return m_nLockThreadID != cThreadId::k_NULL;
                }
                inline THREADID_t get_ThreadLockOwner() const
                {
                        THREADID_t nTid1 = m_nLockThreadID;
                        ASSERT(nTid1 == cThreadId::k_NULL || cThreadId::IsValidId(nTid1));
                        return nTid1;
                }
                inline bool isThreadLockedByCurrent() const noexcept
                {
                        THREADID_t nTid1 = m_nLockThreadID;
                        THREADID_t nTid2 = cThreadId::GetCurrentId();
                        return cThreadId::IsEqualId(nTid1, nTid2);
                }
        };
 
        class GRAYCORE_LINK cThreadLockFast : public cThreadLockBase
        {
                typedef cThreadLockBase SUPER_t;
        public:
                cThreadLockFast() noexcept
                {
                }
                cThreadLockFast(const cThreadLockFast& a) noexcept
                {
                        UNREFERENCED_REFERENCE(a);
                }
                ~cThreadLockFast() noexcept
                {
                }
 
                bool ClearThreadLockOwner(THREADID_t nTid)
                {
                        THREADID_t nTidowner = InterlockedN::CompareExchange(&m_nLockThreadID, cThreadId::k_NULL, nTid);
                        return cThreadId::IsEqualId(nTidowner, nTid);
                }
 
                void Lock();
                bool LockTry(TIMESYSD_t dwDelayMS = 0);
 
                inline void Unlock()
                {
                        ASSERT(isThreadLockedByCurrent());
                        if (SUPER_t::DecLockCount() == 0)
                        {
                                InterlockedN::Exchange(&m_nLockThreadID, cThreadId::k_NULL);
                        }
                }
        };
 
        typedef cLockerT<cThreadLockFast> cThreadGuardFast;
 
        class GRAYCORE_LINK cThreadLockMutex : public cThreadLockBase
        {
 
                typedef cThreadLockBase SUPER_t;
        public:
#ifdef _WIN32
                cOSHandle m_Mutex;
#else // __linux__
                pthread_mutex_t m_Mutex;        // PTHREAD_MUTEX_INITIALIZER
                static const pthread_mutex_t k_MutexInit;       // PTHREAD_MUTEX_INITIALIZER
#endif
        protected:
                bool m_bInitialOwner;           
 
        public:
                cThreadLockMutex(const cThreadLockMutex& a) noexcept
                        : m_bInitialOwner(false)
                {
                        UNREFERENCED_REFERENCE(a);
                        InitLockMutex(nullptr, false);
                }
                cThreadLockMutex(const FILECHAR_t* pszMutexName = nullptr, bool bInitialOwner = false) noexcept
                        : m_bInitialOwner(bInitialOwner)
                {
                        InitLockMutex(pszMutexName, bInitialOwner);
                }
                inline ~cThreadLockMutex() noexcept
                {
                        // DEBUG_CHECK( ! IsLocked());
                        if (m_bInitialOwner && isLocked())       // m_nLockCount == 1
                        {
                                this->Unlock();
                        }
#if defined(__linux__)
                        ::pthread_mutex_destroy(&m_Mutex);
#endif
                }
 
        protected:
                void InitLockMutex(const FILECHAR_t* pszMutexName, bool bInitialOwner) noexcept
                {
#ifdef _WIN32
                        m_Mutex.AttachHandle(_FNF(::CreateMutex)(nullptr, bInitialOwner, pszMutexName));
                        if (bInitialOwner)
                        {
                                LockInternal();
                        }
#else // __linux__
                        // Allow this mutex to be opened multiple times in the same thread.
                        m_Mutex = k_MutexInit;          // same as ::pthread_mutex_init() ??
                        if (bInitialOwner)
                        {
                                Lock();
                        }
#endif
                }
 
                inline void LockInternal()
                {
                        m_nLockThreadID = cThreadId::GetCurrentId();
                        SUPER_t::IncLockCount();
                        ASSERT(isThreadLockedByCurrent()); // may have several locks on the same thread.
                }
 
        public:
                inline bool Lock()
                {
#ifdef _WIN32
                        HRESULT hRes = m_Mutex.WaitForSingleObject(cTimeSys::k_INF);
                        if (hRes != S_OK)
                        {
                                return false;
                        }
#else
                        // If the mutex is already locked (by diff thread), the calling thread blocks until the mutex becomes available
                        int iRet = ::pthread_mutex_lock(&m_Mutex);
                        if (iRet)
                        {
                                // error on lock. EINVAL
                                return false;
                        }
#endif
                        LockInternal(); // may have several locks on the same thread.
                        return true;
                }
                inline bool Unlock()
                {
                        // Assume i own the lock. so thread safe isn't a worry on entry.
                        ASSERT(isThreadLockedByCurrent()); // may have several locks on the same thread.
                        if (SUPER_t::DecLockCount() <= 0)
                        {
                                m_nLockThreadID = cThreadId::k_NULL;
                        }
#ifdef _WIN32
                        return ::ReleaseMutex(m_Mutex) ? true : false;
#else
                        ::pthread_mutex_unlock(&m_Mutex);
                        return true;
#endif
                }
 
                bool LockTry(TIMESYSD_t dwDelayMS = 0)
                {
#ifdef _WIN32
                        HRESULT hRes = m_Mutex.WaitForSingleObject(dwDelayMS);
                        if (hRes != S_OK)
                        {
                                return false;
                        }
#elif defined(__USE_XOPEN2K)    // __linux__
                        cTimeSpec tSpec(dwDelayMS);
                        int iRet = ::pthread_mutex_timedlock(&m_Mutex, &tSpec);
                        if (iRet != 0)
                        {
                                return false;
                        }
#else
                        // if pthread_mutex_timedlock() is not available.
                        TIMESYSD_t dwWaitTimeMS = 0;
                        for (;;)
                        {
                                if (::pthread_mutex_trylock(&m_Mutex) == 0)
                                        break;
                                if (dwDelayMS <= 0)     // EBUSY
                                {
                                        return false; // FAILED to lock
                                }
                                cThreadId::SleepCurrent(dwWaitTimeMS); // wait for a tick.
                                if (dwWaitTimeMS == 0)
                                {
                                        dwWaitTimeMS = 1;
                                }
                                else
                                {
                                        dwDelayMS--;
                                }
                        }
#endif
                        LockInternal();
                        return true;
                }
        };
 
        typedef cLockerT<cThreadLockMutex> cThreadGuardMutex;
 
#ifdef _WIN32
        class GRAYCORE_LINK cThreadLockCrit : public cThreadLockBase
        {
 
        protected:
                CRITICAL_SECTION m_CritSection; // RTL_CRITICAL_SECTION, more efficient than a MUTEX. but takes more memory to store.
 
        private:
                void LockInternal()
                {
                        m_nLockThreadID = cThreadId::GetCurrentId();
                        IncLockCount();
                        ASSERT(isThreadLockedByCurrent()); // may have several locks on the same thread.
                }
                void InitLockCrit()
                {
                        ::InitializeCriticalSection(&m_CritSection);
                }
 
        public:
                cThreadLockCrit(const cThreadLockCrit& a)
                {
                        UNREFERENCED_REFERENCE(a);
                        InitLockCrit();
                }
                cThreadLockCrit()
                {
                        InitLockCrit();
                }
                inline ~cThreadLockCrit()
                {
                        ::DeleteCriticalSection(&m_CritSection);
                }
 
        public:
                inline void Lock()
                {
                        ::EnterCriticalSection(&m_CritSection);
                        LockInternal();
                }
                inline void Unlock()
                {
                        ASSERT(isThreadLockedByCurrent()); // may have several locks on the same thread.
                        if (DecLockCount() <= 0)
                        {
                                m_nLockThreadID = cThreadId::k_NULL;
                        }
                        ::LeaveCriticalSection(&m_CritSection);
                }
 
#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
                bool LockTry()
                {
                        if (::TryEnterCriticalSection(&m_CritSection) == 0)
                                return false;
                        LockInternal();
                        return true;
                }
#endif
        };
#else
        typedef cThreadLockMutex cThreadLockCrit;       // just substitute it if not _WIN32.
#endif // _WIN32
 
        class cThreadLockStub : public cLockableBase
        {
        public:
                inline THREADID_t get_ThreadLockOwner() const
                {
                        return (THREADID_t)isLocked() ? 1 : 0;
                }
        };
 
        //****************************************************************************
 
#if defined(_MT) || defined(__linux__)
        typedef cThreadLockFast cThreadLockCount;
#else
        typedef cThreadLockStub cThreadLockCount;
#endif
        typedef cLockerT<cThreadLockCount> cThreadGuard;        // instantiated locker.
};
 
#endif // _INC_cThreadLock_H