TnbThreadLocalObject.h

[詳解]

#pragma once 
#include "TnbMap.h"
 
 
 
namespace TNB
{
 
 
 
template<typename TYP>
class CThreadLocalObjectT
{
    DWORD                       m_dwTlsIndex;   
    TYP                         m_typ;          
    mutable CVectorT<TYP*>      m_vpTyp;        
    TYP& m_Get(void) const
    {
        TYP* P = static_cast<TYP*>(::TlsGetValue(m_dwTlsIndex));
        if ( P == NULL )
        {
            P = new TYP(m_typ);
            m_vpTyp.Add(P);
            ::TlsSetValue(m_dwTlsIndex, P);
        }
        return *P;
    }
 
public:
 
    CThreadLocalObjectT(const TYP& t = TYP()) : m_typ(t)
    {
        m_dwTlsIndex = ::TlsAlloc();
        if ( m_dwTlsIndex == TLS_OUT_OF_INDEXES )
        {
            throw CEmptyException();
        }
    }
 
    ~CThreadLocalObjectT(void)
    {
        loop ( i, m_vpTyp.GetSize() )
        {
            delete m_vpTyp.At(i);
        }
        m_vpTyp.RemoveAll();
        ::TlsFree(m_dwTlsIndex);
    }
 
    const TYP& Get(void) const
    {
        return m_Get();
    }
 
    void Set(const TYP& t)
    {
        m_Get() = t;
    }
};
 
 
 
template<typename TYP>
class CThreadLocalObjectExT
{
    TYP                         m_typ;          
    mutable CMapT<DWORD, TYP>   m_mapTyp;       
public:
 
    CThreadLocalObjectExT(const TYP& t = TYP()) : m_typ(t)
    {
    }
 
    ~CThreadLocalObjectExT(void)
    {
    }
 
    const TYP& Get(void) const
    {
        EXCLUSIVE(&m_mapTyp);
        DWORD dw = ::GetCurrentThreadId();
        if ( ! m_mapTyp.HasKey(dw) )
        {
            m_mapTyp[dw] = m_typ;
        }
        return m_mapTyp[dw];
    }
 
    void Set(const TYP& t)
    {
        EXCLUSIVE(&m_mapTyp);
        DWORD dw = ::GetCurrentThreadId();
        if ( ! m_mapTyp.HasKey(dw) )
        {
            m_mapTyp[dw] = m_typ;
        }
        m_mapTyp[dw] = t;
    }
};
 
 
 
};
 
 
 
#if 0
 
DWORD gdwTlsIndex = 0;
 
CThreadLocalStorageT<DWORD> s_tsl_dwData;
CThreadLocalObjectT<CStr> s_tsl_strData = "#";
 
 
 
class Receiver : public CSocketUdp::IListener
{
public:
    virtual bool OnSocketEvent(const CSocketEvent& event)
    {
        DWORD r = s_tsl_dwData.Get();
        s_tsl_dwData.Set(::GetCurrentThreadId());
        TRACE2("[%08X] : %08X\n",::GetCurrentThreadId(), r);
 
        CStr s = s_tsl_strData.Get();
        s_tsl_strData.Set("Thread!!");
        TRACE2("[%08X] : %s\n",::GetCurrentThreadId(),s);
 
 
 
 
        if ( event.HasEvent() )
        {
            TRACE1("%s\n",event.GetEventString());
        }
        else
        {
            TNB::DumpData(event.GetDataSize(),event.GetData());
            CStr str;
            WORD wPort;
            event.GetPeerName(str, wPort);
            TRACE2("%s %d\n", str, wPort);
            event.Send(2,"AB");
        }
        return true;
    }
};
 
 
 
void CTnbTestDlg::OnBtnVir() 
{
    CDwordVector vdwIndex;
    while ( true )
    {
        DWORD d = ::TlsAlloc();
        if ( d == TLS_OUT_OF_INDEXES )
        {
            break;
        }
        vdwIndex.Add(d);
    }
    TRACE1("max= %d\n",vdwIndex.GetSize());
 
 
 
 
    DWORD r = s_tsl_dwData.Get();
    s_tsl_dwData.Set(10222);
 
    CStr s = s_tsl_strData.Get();
    s_tsl_strData.Set("Main");
 
 
#endif