cThreadLockRW.h

Go to the documentation of this file.

//
 
#ifndef _INC_cThreadLockRW_H
#define _INC_cThreadLockRW_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cThreadLock.h"
#include "cInterlockedVal.h"
#include "cNonCopyable.h"
#include "cThreadLockRef.h"
 
namespace Gray
{
        class GRAYCORE_LINK cThreadLockRWS : protected cNonCopyable
        {
 
        private:
                cInterlockedInt m_nReaders;
                cInterlockedInt m_nWriters;
 
        public:
                void IncReadLockCount()
                {
                        for (;;)
                        {
                                m_nReaders.IncV();
                                if (m_nWriters == 0)
                                        break;
                                m_nReaders.DecV();
                                cThreadId::SleepCurrent(0);
                        }
                }
                void DecReadLockCount()
                {
                        m_nReaders.DecV();
                }
 
                void Lock()
                {
                        // Write lock
                        for (;;)
                        {
                                if (m_nWriters.Exchange(1) == 1)
                                {
                                        cThreadId::SleepCurrent(0);
                                }
                                else
                                {
                                        while (m_nReaders != 0)
                                                cThreadId::SleepCurrent(0);
                                        break;
                                }
                        }
                }
 
                void Unlock()
                {
                        // Write unlock
                        m_nWriters.DecV();
                }
        };
 
        class GRAYCORE_LINK cThreadLockRW : public cThreadLockFast
        {
 
                typedef cThreadLockFast SUPER_t;
 
        public:
                // cThreadLock::m_nLockThreadID;                // First reader or writers .
                // cThreadLock::m_nLockCount;                   // How many write locks (for orig m_nLockThreadID)
                cInterlockedInt m_nReadLockCount;               
                cInterlockedInt m_nOtherReadLockCount;  
                bool m_bLostOrder;      
 
        public:
                cThreadLockRW()
                : m_bLostOrder(false)
                {
                }
                ~cThreadLockRW()
                {
                        ASSERT(m_nReadLockCount == 0);
                        ASSERT(m_nOtherReadLockCount == 0);
                }
 
                inline void IncReadLockCount()
                {
                        // this is a slightly softer READ lock.
                        if (SUPER_t::LockTry())
                        {
                                // I'm first locker or at least the same thread as the first.
                                m_nReadLockCount.IncV();
                                return;
                        }
                        // some other thread has the write/read lock before me. can i just read it ?
                        m_nOtherReadLockCount.IncV();
                        if (m_nReadLockCount == get_LockCount())        // another reader is OK.
                        {
                        }
                        else
                        {
                        }
                }
                inline void DecReadLockCount()
                {
                }
                UNITTEST_FRIEND(cThreadLockRW);
        };
 
        class cThreadGuardRead : public cLockerT < cThreadLockRW >
        {
 
        public:
                cThreadGuardRead(cThreadLockRW& rLock)
                : cLockerT<cThreadLockRW>(rLock)
                {
                }
                // TODO: call IncReadLockCount
        };
 
        typedef cLockerT<cThreadLockRW> cThreadGuardWrite;      // I only want to write to this.
 
        //******************************************************
 
        class GRAYCORE_LINK cThreadLockableRW
        : public cRefBase
        , public cThreadLockRW
        {
        };
 
        template<class TYPE>
        class CSmartReadPtr : public cRefPtr<TYPE>, public cThreadGuardRead
        {
 
                CSmartReadPtr(TYPE* pObj)
                : cRefPtr<TYPE>(pObj)
                , cThreadGuardRead(*pObj)
                {
                }
 
                const TYPE* get_Ptr() const
                {
                        return(this->m_pObj);
                }
        };
        template<class TYPE>
        class CSmartWritePtr : public cRefPtr<TYPE>, public cThreadGuardWrite
        {
                CSmartWritePtr(TYPE* pObj)
                : cRefPtr<TYPE>(pObj)
                , cThreadGuardWrite(*pObj)
                {
                }
        };
};
#endif // _INC_cThreadLockRW_H