TnbSync.h

[詳解]

#pragma once
#include "TnbException.h"
#include "TnbTickCount.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
#include <malloc.h>
 
 
 
//TNB Library
namespace TNB
{
 
 
 
struct ISynchronized
{
    virtual ~ISynchronized(void) {}
 
    virtual bool Lock(DWORD dwTime = INFINITE) const = 0;
 
    virtual void Unlock(void) const = 0;
};
 
 
 
class CAbstractSyncHandle : public ISynchronized
{
public:
 
    virtual HANDLE GetHandle(void) const = 0;
 
    operator HANDLE(void) const 
    {
        return GetHandle(); 
    }
    
    virtual bool Lock(DWORD dwTime = INFINITE) const
    {
        HANDLE h = GetHandle();
        if ( h != NULL )
        {
            DWORD dwRc = ::WaitForSingleObject(h, dwTime);
            ASSERTLIB(dwRc != WAIT_FAILED);
            if ( dwRc == WAIT_OBJECT_0 )
            {
                return true;//成功した
            }
        }
        return false;
    }
};
 
 
class CSyncSection : public ISynchronized, CCopyImpossible
{
public:
 
    CSyncSection(void)
    {
        ::InitializeCriticalSection(&m_cs); 
    }
 
    virtual ~CSyncSection(void)
    {
        ::DeleteCriticalSection(&m_cs); 
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const
    {
        ::EnterCriticalSection(&m_cs);
        return true;
    }
 
    virtual void Unlock(void) const
    {
        ::LeaveCriticalSection(&m_cs); 
    }
 
private:
    mutable CRITICAL_SECTION    m_cs;   
    friend class CSyncSectionEx;        
};
 
 
 
class CSyncSectionEx : public CSyncSection
{
    DEFSUPER(CSyncSection); 
public:
 
    CSyncSectionEx(void) : _super(), m_hModule(NULL), m_pTryEntryCs(NULL)
    {
    }
 
    virtual ~CSyncSectionEx(void)
    {
        if ( m_hModule != NULL )
        {
            ::FreeLibrary(m_hModule);
            m_hModule = NULL;
        }
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const
    {
        if ( dwTime == INFINITE )
        {
            return _super::Lock(dwTime);
        }
        if ( m_hModule == NULL )
        {
            m_hModule = ::LoadLibraryA("kernel32.dll");
            m_pTryEntryCs = reinterpret_cast<P_TryEntryCs>(::GetProcAddressA(m_hModule, "TryEnterCriticalSection"));
        }
        if ( m_pTryEntryCs == NULL )
        {
            ASSERT0(false, "CSyncSectionEx::Lock()", 
                    "API 'TryEnterCriticalSection()' が見つかりません。\nOS がNT4.0以降でない可能性があります。");
            return false;
        }
        if ( dwTime == 0 )
        {
            return !! m_pTryEntryCs(&m_cs); //TryEntryCriticalSection実行
        }
        CTickCount tick;
        while ( ! tick.IsPassed(dwTime) )
        {
            if ( m_pTryEntryCs(&m_cs) ) //TryEntryCriticalSection実行
            {
                return true;
            }
            ::Sleep(1);
        }
        return false;
    }
 
private:
    typedef DWORD (WINAPI* P_TryEntryCs)(LPCRITICAL_SECTION);
    mutable P_TryEntryCs m_pTryEntryCs;         
    mutable HMODULE         m_hModule;          
};
 
 
 
class CSyncMutex : public CAbstractSyncHandle , CCopyImpossible
{
    DEFSUPER(CAbstractSyncHandle);
public:
 
    explicit CSyncMutex(bool boIsLock = false, LPCTSTR lpszName = NULL) : _super()
    {
        m_hMutex = ::CreateMutex(NULL, boIsLock, lpszName);
        DWORD r = ::GetLastError();
        if ( r != 0 && r != 0xB7 )
        {
            _GetLastError("CreateMutex");
        }
        ASSERT0(
            m_hMutex != NULL,
            "CSyncMutex::CSyncMutex()",
            "Mutexが初期化できませんした。"
        );
        if ( m_hMutex == NULL )
        {
            throw CInvalidParamException();
        }
    }
 
    explicit CSyncMutex(HANDLE hMutex) : _super()
    {
        m_hMutex = hMutex;
        if ( m_hMutex == NULL )
        {
            throw CInvalidParamException();
        }
    }
 
    virtual ~CSyncMutex(void)
    {
        if ( m_hMutex != NULL )
        {
            ::ReleaseMutex(m_hMutex);
            ::CloseHandle(m_hMutex);
        }
    }
 
    virtual void Unlock(void) const
    {
        if ( m_hMutex != NULL )
        {
            ::ReleaseMutex(m_hMutex);
        }
    }
 
    virtual HANDLE GetHandle(void) const 
    {
        return m_hMutex; 
    }
 
private:
    HANDLE  m_hMutex;               
};
 
 
 
class CSyncSemaphore : public CAbstractSyncHandle , CCopyImpossible
{
    DEFSUPER(CAbstractSyncHandle);
public:
 
    explicit CSyncSemaphore(LPCTSTR lpszName = NULL, int iMaximumCount = 1) : _super()
    {
        m_hSema = ::CreateSemaphore(NULL, iMaximumCount, iMaximumCount, lpszName);
        ASSERT0(
            m_hSema != NULL,
            "CSyncSemaphore::CSyncSemaphore()",
            "Semaphoreが初期化できませんした。"
        );
        if ( m_hSema == NULL )
        {
            throw CInvalidParamException();
        }
    }
 
    explicit CSyncSemaphore(HANDLE hSema) : _super()
    {
        m_hSema = hSema;
        if ( m_hSema == NULL )
        {
            throw CInvalidParamException();
        }
    }
 
    virtual ~CSyncSemaphore(void)
    {
        if ( m_hSema != NULL )
        {
            ::ReleaseSemaphore(m_hSema, 1, NULL);
            ::CloseHandle(m_hSema);
        }
    }
 
    virtual void Unlock(void) const
    {
        if ( m_hSema != NULL )
        {
            ::ReleaseSemaphore(m_hSema, 1, NULL);
        }
    }
 
    LONG Unlock(LONG lCount) const
    {
        LONG l = 0;
        if ( m_hSema != NULL )
        {
            ::ReleaseSemaphore(m_hSema, lCount, &l);
        }
        return l;
    }
 
    virtual HANDLE GetHandle(void) const 
    {
        return m_hSema; 
    }
 
private:
    HANDLE  m_hSema;                
};
 
 
 
class CSyncEvent : public CAbstractSyncHandle , CCopyImpossible
{
    DEFSUPER(CAbstractSyncHandle);
public:
 
    explicit 
    CSyncEvent(bool boIsManualReset = false, bool boIsLock = false, LPCTSTR lpszName = NULL) : _super()
    {
        m_hEvent = ::CreateEvent(NULL, boIsManualReset, ! boIsLock, lpszName);
        ASSERT0(
            m_hEvent != NULL,
            "CSyncEvent::CSyncEvent()",
            "Eventが初期化できませんした。名前に問題がある可能性が有ります。"
        );
        if ( m_hEvent == NULL )
        {
            throw CInvalidParamException();
        }
    }
 
    explicit CSyncEvent(HANDLE hEvent) : _super()
    {
        m_hEvent = hEvent;
        if ( m_hEvent == NULL )
        {
            throw CInvalidParamException();
        }
    }
 
    virtual ~CSyncEvent(void)
    {
        if ( m_hEvent != NULL )
        {
            ::SetEvent(m_hEvent);
            ::CloseHandle(m_hEvent);
        }
    }
 
    virtual void Unlock(void) const
    {
        if ( m_hEvent != NULL )
        {
            ::SetEvent(m_hEvent);
        }
    }
 
    void ToLock(void)
    {
        if ( m_hEvent != NULL )
        {
            ::ResetEvent(m_hEvent);
        }
    }
 
    void Pulse(void)
    {
        if ( m_hEvent != NULL )
        {
            ::PulseEvent(m_hEvent);
        }
    }
 
    virtual HANDLE GetHandle(void) const 
    {
        return m_hEvent; 
    }
 
private:
    HANDLE  m_hEvent;               
};
 
 
 
class CSyncCounter : public ISynchronized, CCopyImpossible
{
public:
 
    CSyncCounter(LONG lMax=1) : m_lCounter(0), m_lMax(lMax) 
    {
    }
 
    virtual ~CSyncCounter(void)
    {
        ASSERT0(
            m_lCounter == 0,
            "CSyncCounter::~CSyncCounter()",
            "内部ロックカウントの数が合いません。\n\tLock()とUnlock()回数があっていない可能性が有ります。"
        );
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const
    {
        if ( dwTime == 0 )
        {
            return m_check();
        }
        else if ( dwTime == INFINITE )
        {
            while ( true )
            {
                if ( m_check() )
                {
                    return true;
                }
                ::Sleep(1);
            }
        }
        else
        {
            CTickCount tick;
            while ( ! tick.IsPassed(dwTime) )
            {
                if ( m_check() )
                {
                    return true;
                }
                ::Sleep(1);
            }
        }
        return false;
    }
 
    virtual void Unlock(void) const
    {
        if ( ::InterlockedDecrement(&m_lCounter) < 0 )
        {
            ASSERT0(false, "CSyncCounter::Unlock()", "Unlock()回数がLock()よりも多いです。");
            ::InterlockedExchange(&m_lCounter, 0);
        }
    }
 
private:
    mutable LONG    m_lCounter; 
    LONG            m_lMax;     
 
    bool m_check(void) const
    {
        if ( ::InterlockedIncrement(&m_lCounter) <= m_lMax )
        {
            return true;
        }
        ::InterlockedDecrement(&m_lCounter);
        return false;
    }
};
 
 
 
class CSyncDummy : public ISynchronized
{
public:
 
    CSyncDummy(void) {}
 
    virtual ~CSyncDummy(void) {}
 
    virtual bool Lock(DWORD dwTime = INFINITE) const 
    {
        return true; 
    }
 
    virtual void Unlock(void) const {}
};
 
 
 
class CExclusive
{
public:
 
    explicit CExclusive(const ISynchronized* P) : m_psyncObj(P)
    {
        if ( m_psyncObj == NULL )
        {
            throw CNullPointerException();
        }
        m_psyncObj->Lock();
    }
 
    ~CExclusive(void)
    {
        m_psyncObj->Unlock(); 
    }
 
private:
    const ISynchronized *   m_psyncObj; 
};
 
 
 
#define EXCLUSIVE(CLS)      CExclusive _cExclus_(CLS);
 
 
#define EXCLUSIVE_(CLS) \
                    TRACE3("%s(%d):[%d] Lock要求\n",_T(__FILE__),__LINE__,::GetCurrentThreadId());    \
                    CExclusive _cExclus_(CLS);                                                      \
                    TRACE3("%s(%d):[%d] Lock成功\n",_T(__FILE__),__LINE__,::GetCurrentThreadId());
 
 
 
#define EXCLUSIVE2(CLS1,CLS2)   CExclusive _cExclus1_(CLS1); CExclusive _cExclus2_(CLS2);
 
 
 
#define EXCLUSIVE2_(CLS1,CLS2)  \
                    TRACE3("%s(%d):[%d] Lock要求\n",_T(__FILE__),__LINE__,::GetCurrentThreadId());    \
                    CExclusive _cExclus1_(CLS1); CExclusive _cExclus2_(CLS2);                       \
                    TRACE3("%s(%d):[%d] Lock成功\n",_T(__FILE__),__LINE__,::GetCurrentThreadId());
 
 
 
class CExclusiveEx : public CExclusive
{
    DEFSUPER(CExclusive); 
public:
 
    explicit CExclusiveEx(const ISynchronized* P) : _super(P), m_iChkCnt(0) 
    {
    }
 
    operator int(void)
    {
        return m_iChkCnt++;
    }
 
private:
    int         m_iChkCnt;  
};
 
 
 
#define SYNCBLOCK(CLS) if (false); else for ( CExclusiveEx _cExclusEx_(CLS); _cExclusEx_ == 0; )
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")