设计自己的线程局部存储

先贴代码：

_AFXTLS_.h:

#ifndef _AFXTLS_H_
#define _AFXTLS_H_
#include<stdio.h>
#include<windows.h>
#include<stddef.h>
#include<iostream>
using namespace std;

class CSimpleList
{
    public:
            CSimpleList(int nNextOffSet = 0);
            void Construct(int nNextOffset);
            //给用户的函数接口
            bool  IsEmpty() const;
            void  AddHead(void* p);
            void* GetHead() const;
            bool  Remove(void* p);
            void  RemoveAll();
            void* GetNext(void* p) const;
            //需要用到的成员
            void* m_pHead;
            int   m_nNextOffSet;
            void** GetNextPtr(void* p) const;
};
inline CSimpleList::CSimpleList(int nNextOffSet)
{
    m_pHead = NULL;
    m_nNextOffSet = nNextOffSet;
}
inline void CSimpleList::Construct(int nNextOffSet)
{
    m_nNextOffSet = nNextOffSet;
}
inline bool CSimpleList::IsEmpty() const
{
    return m_pHead == NULL;
}
inline void* CSimpleList::GetHead() const
{
    return m_pHead;
}
inline void CSimpleList::RemoveAll()
{
    m_pHead = NULL;
}
inline void** CSimpleList::GetNextPtr(void* p) const
{
    return (void**)((BYTE*)p + m_nNextOffSet);
}
inline void* CSimpleList::GetNext(void* p) const
{
    return *GetNextPtr(p);
}
template<class TYPE>
class CTypedSimpleList : public CSimpleList
{
    public:
            CTypedSimpleList(int nNextOffSet = 0):CSimpleList(nNextOffSet){};
            void  AddHead(TYPE p)
            {
                CSimpleList::AddHead((void*)p);
            }
            TYPE GetHead() const
            {
                return (TYPE)CSimpleList::GetHead();
            }
            bool  Remove(TYPE p)
            {
                return CSimpleList::Remove((void*)p);
            }
            TYPE  GetNext(void* p) const
            {
                return (TYPE)CSimpleList::GetNext(p);
            }
            operator TYPE()
            {
                return (TYPE)CSimpleList::GetHead();
            }
};
class CNoTrackObject
{
    public:
            void* operator new(size_t nSize);
            void  operator delete(void* p);
            virtual ~CNoTrackObject(){};
};
struct CSlotData;
struct CThreadData;
class CSlotThreadData
{
    public:
        //构造函数
        CSlotThreadData();
        //接口函数
        int SlotAlloc();
        void SlotFree(int nSlot);
        void* GetThreadValue(int nSlot);
        void SetThreadValue(int nSlot,void* pValue);
        void DeleteValues(HINSTANCE hInst,bool bAll = false);
        //成员
        void DeleteValues(CThreadData* pData,HINSTANCE hInst);
        void* operator new(size_t,void* p)
        {
            return p;
        }
        DWORD m_tlsIndex;
        int m_nAlloc;
        int m_nRover;
        int m_nMax;
        CSlotData* m_pSlotData;
        CTypedSimpleList<CThreadData*> m_list;
        CRITICAL_SECTION m_cs;
        //析构函数
        ~CSlotThreadData(); 
};

class CThreadLocalObject
{
    public:
        CNoTrackObject* GetData(CNoTrackObject* (*pCreateObject)());
        CNoTrackObject* GetDataNA();
        int m_nSlot;
        ~CThreadLocalObject();
};
template<class TYPE>
class CThreadLocal:public CThreadLocalObject
{
    public:
        static CNoTrackObject* CreateObject()
        {
            return new TYPE;
        }
        TYPE* GetData()
        {
            return (TYPE*)CThreadLocalObject::GetData(&CreateObject);
        }
        TYPE* GetDataNA()
        {
            return (TYPE*)CThreadLocalObject::GetDataNA();
        }
        operator TYPE*()
        {
            return GetData();
        }
        TYPE* operator ->()
        {
            return GetData();
        }
};

#endif

_AFXTLS_.cpp:

#include"_AFXTLS_.h"
#ifdef _AFXTLS_H_
void CSimpleList::AddHead(void* p)
{
    *GetNextPtr(p) = m_pHead;
    m_pHead = p;
}

bool CSimpleList::Remove(void* p)
{
    //如果p为空 结束函数 
    if(p == NULL)
    return false;
    
    bool bRet = false;//先假定删除失败
    
    if(p == m_pHead)
    {
        m_pHead = GetNext(p);
    }
    else 
    {
        void* pTest = m_pHead;
        while(pTest != NULL && p != GetNext(pTest))
        {
            pTest = GetNext(pTest);
        }
        if(pTest == NULL)
        {
            printf("pTest == NULL
");
            return bRet;
        }
        *GetNextPtr(pTest) = GetNext(p);
    }
    bRet = true;
    return bRet;
}

void* CNoTrackObject::operator new(size_t nSize)
{
    void* p = ::GlobalAlloc(GPTR,nSize);
    return p;
}
void CNoTrackObject::operator delete(void* p)
{
    if(p != NULL)
    {
        ::GlobalFree(p);
    }
}

BYTE __afxThreadData[sizeof(CSlotThreadData)];
CSlotThreadData* _afxThreadData;
struct CSlotData
{
    DWORD dwFlags;
    HINSTANCE hInst;
};
struct CThreadData:public CNoTrackObject
{
    CThreadData* pNext;
    int nCount;
    LPVOID* pData;
};

#define SLOT_USED 0x01

CSlotThreadData::CSlotThreadData()
{
    m_tlsIndex = ::TlsAlloc();
    m_list.Construct(offsetof(CThreadData,pNext));
    m_nAlloc = 0;
    m_nMax = 0;
    m_nRover = 1;
    m_pSlotData = NULL;
    ::InitializeCriticalSection(&m_cs);
}
int CSlotThreadData::SlotAlloc()
{
    ::EnterCriticalSection(&m_cs);
    
    int nAlloc = m_nAlloc;
    int nSlot = m_nRover;
    if(nSlot >= nAlloc||m_pSlotData[nSlot].dwFlags & SLOT_USED)
    {
        for(nSlot = 1;nSlot<nAlloc && m_pSlotData[nSlot].dwFlags&SLOT_USED;nSlot++);
        if(nSlot >= nAlloc)
        {
            int nNewAlloc = nAlloc + 32;
            HGLOBAL p;
            if(m_pSlotData == NULL)
            {
                p = ::GlobalAlloc(GMEM_MOVEABLE,sizeof(CSlotData)*nNewAlloc);
            }
            else 
            {
                p = ::GlobalHandle(m_pSlotData);
                ::GlobalUnlock(p);
                p = ::GlobalReAlloc(p,sizeof(CSlotData)*nNewAlloc,GMEM_MOVEABLE);
            }
            CSlotData* pData = (CSlotData*)::GlobalLock(p);
            memset(pData+nAlloc,0,(nNewAlloc-nAlloc)*sizeof(CSlotData));
            m_pSlotData = pData;
            m_nAlloc = nNewAlloc;
        }
    }
    if(nSlot >= m_nMax)
    {
        m_nMax = nSlot+1;
    }
    m_pSlotData[nSlot].dwFlags |= SLOT_USED;
    m_nRover = nSlot+1;
    ::LeaveCriticalSection(&m_cs);
    return nSlot;
}

void CSlotThreadData::SetThreadValue(int nSlot,void* pValue)
{
    CThreadData* pData = (CThreadData*)::TlsGetValue(m_tlsIndex);
    if((pData==NULL||pData->nCount <= nSlot)&&pValue != NULL)
    {
        if(pData == NULL)
        {
            pData = new CThreadData;
            pData->nCount = 0;
            pData->pData = NULL;
            ::EnterCriticalSection(&m_cs);
            m_list.AddHead(pData);
            ::LeaveCriticalSection(&m_cs);
        }
        if(pData->pData == NULL)
        {
            pData->pData = (void**)::LocalAlloc(LMEM_FIXED,sizeof(LPVOID)*m_nMax);
        }
        else 
        {
            pData->pData = (void**)::LocalReAlloc(pData->pData,sizeof(LPVOID)*m_nMax,LMEM_MOVEABLE);
        }
        memset(pData->pData+pData->nCount,0,sizeof(LPVOID)*(m_nMax - pData->nCount));
        pData->nCount = m_nMax;
        ::TlsSetValue(m_tlsIndex,pData);
    }
    pData->pData[nSlot] = pValue;
}

void* CSlotThreadData::GetThreadValue(int nSlot)
{
    CThreadData* pData = (CThreadData*)::TlsGetValue(m_tlsIndex);
    if(pData == NULL||pData->nCount<= nSlot)
    {
        return NULL;
    }
    return pData->pData[nSlot];
}

void CSlotThreadData::SlotFree(int nSlot)
{
    ::EnterCriticalSection(&m_cs);
    CThreadData* pData = m_list;
    while(pData != NULL)
    {
        if(pData->nCount > nSlot)
        {
            delete (CNoTrackObject*) pData->pData[nSlot];
            pData->pData[nSlot] = NULL;
        }
        pData = pData->pNext;
    }
    m_pSlotData[nSlot].dwFlags &= ~SLOT_USED;
    ::LeaveCriticalSection(&m_cs);
}

void CSlotThreadData::DeleteValues(HINSTANCE hInst,bool bAll )
{
    ::EnterCriticalSection(&m_cs);
    if(!bAll)
    {
        CThreadData* pData = (CThreadData*)::TlsGetValue(m_tlsIndex);
        if(pData != NULL)
        {
            DeleteValues(pData,hInst);
        }
    }
    else 
    {
        CThreadData* pData = m_list;
        while(pData !=NULL)
        {
            CThreadData* pNextData = pData->pNext;
            DeleteValues(pData,hInst);
            pData = pNextData;
        }
    }
    ::LeaveCriticalSection(&m_cs);
}

void CSlotThreadData::DeleteValues(CThreadData* pData,HINSTANCE hInst)
{
    bool bDelete = true;
    for(int i = 1;i<pData->nCount;i++)
    {
        if(m_pSlotData[i].hInst == hInst||hInst == NULL)
        {
            delete (CNoTrackObject*) pData->pData[i];
            pData->pData[i] = NULL;
        }
        else
        {
            if(m_pSlotData[i].hInst != NULL)
            {
                bDelete = false;
            }
        }
    }
    if(bDelete)
    {
        ::EnterCriticalSection(&m_cs);
        m_list.Remove(pData);
        ::LeaveCriticalSection(&m_cs);
        ::LocalFree(pData->pData);
        delete pData;
        ::TlsSetValue(m_tlsIndex,NULL);
    }
}

CSlotThreadData::~CSlotThreadData()
{
    CThreadData* pData = m_list;
    while(pData != NULL)
    {
        CThreadData* p = pData->pNext;
        DeleteValues(pData,NULL);
        pData = p;
    }
    if(m_tlsIndex != (DWORD)-1)
    {
        ::TlsFree(m_tlsIndex);
    }
    if(m_pSlotData!= NULL)
    {
        HGLOBAL hSlotData = ::GlobalHandle(m_pSlotData);
        ::GlobalUnlock(hSlotData);
        ::GlobalFree(hSlotData);
    }
    ::DeleteCriticalSection(&m_cs);
}

CNoTrackObject* CThreadLocalObject::GetData(CNoTrackObject* (*pCreateObject)())
{
    if( _afxThreadData == NULL || m_nSlot == 0)
    {
        if(_afxThreadData == NULL)
        {
            _afxThreadData = new (__afxThreadData)CSlotThreadData;
        }
        m_nSlot = _afxThreadData->SlotAlloc();
    }
    CNoTrackObject* pValue = (CNoTrackObject*)_afxThreadData->GetThreadValue(m_nSlot);
    if(pValue == NULL)
    {
        pValue = (*pCreateObject)();
        _afxThreadData->SetThreadValue(m_nSlot,pValue);
    }
    return pValue;
}

CNoTrackObject* CThreadLocalObject::GetDataNA()
{
    if(_afxThreadData == NULL || m_nSlot == 0)
    {
        return NULL;
    }
    return (CNoTrackObject*)_afxThreadData->GetThreadValue(m_nSlot);
}
CThreadLocalObject::~CThreadLocalObject()
{
    if(m_nSlot!=0&&_afxThreadData != NULL)
        _afxThreadData->SlotFree(m_nSlot);
    m_nSlot = 0;
}
#endif

_AFXSTAT.h:

#ifndef _AFXSTATE_H_

#define _AFXSTATE_H_

#ifndef _AFXTLS_H_
#include"_AFXTLS_.h"
#endif

class CWinThread;

class AFX_MODULE_THREAD_STATE:public CNoTrackObject
{
    public:
    CWinThread* m_pCurrentWinThread;
};
AFX_MODULE_THREAD_STATE* AfxGetModuleThreadState();
extern CThreadLocal<AFX_MODULE_THREAD_STATE> _afxModuleThreadState;
#endif

_AFXSTATE.cpp:

#include"_AFXSTAT.h"
#ifdef _AFXSTATE_H_
AFX_MODULE_THREAD_STATE* AfxGetModuleThreadState()
{
    return _afxModuleThreadState.GetData();
}
CThreadLocal<AFX_MODULE_THREAD_STATE> _afxModuleThreadState;
#endif

_AFXWIN.h:

#ifndef _AFXWIN_H_
#define _AFXWIN_H_

#include"_AFXSTAT.h"
//#include<process.h>
typedef UINT (__cdecl *AFX_THREADPROC)(LPVOID);

class CWinThread
{
    public:
        CWinThread();
        bool CreateThread(UINT dwStackSize = 0,DWORD  dwCreateFlags = 0,LPSECURITY_ATTRIBUTES lpThreadAttributes = NULL);
        
        bool m_bAutoDelete;
        HANDLE m_hThread;
        UINT m_uId;
        
        operator HANDLE ()
        {
            return this==NULL?NULL:m_hThread;
        }
        
        int GetThreadPriority()
        {
            return ::GetThreadPriority(m_hThread);
        }
        bool SetThreadPriority(int nPriority)
        {
            return ::SetThreadPriority(m_hThread,nPriority);
        }
        
        DWORD SuspendThread()
        {
            return ::SuspendThread(m_hThread);
        }
        DWORD ResumeThread()
        {
            return ::ResumeThread(m_hThread);
        }
        
        virtual void Delete();
        virtual ~CWinThread();
        void CommonConstruct();
        
        AFX_THREADPROC m_pfnThreadProc;
        LPVOID m_pThreadParams;
        
        CWinThread(AFX_THREADPROC pfnThreadProc,LPVOID pParam);
        
};
CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc,LPVOID pParam,
                                        int nPriority = THREAD_PRIORITY_NORMAL,UINT nStackSize = 0,
                                        DWORD dwCreateFlags = 0,LPSECURITY_ATTRIBUTES lpSecurityAtts = NULL);
CWinThread* AfxGetThread();
void AfxEndThread(UINT nExitCode,bool bDelete = true);
#endif

THRDCORE.cpp:

#include"_AFXWIN.h"
#include"_AFXTLS_.h"
extern CSlotThreadData* _afxThreadData;
struct _AFX_THREAD_STARTUP
{
    CWinThread* pThread;
    HANDLE hEvent1;
    HANDLE hEvent2;
    bool bError;
};
UINT __stdcall _AfxThreadEntry(void* pParam)
{
    _AFX_THREAD_STARTUP* pStartup = (_AFX_THREAD_STARTUP*)pParam;
    CWinThread* pThread = pStartup->pThread;
    try
    {
        AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
        pState->m_pCurrentWinThread = pThread;
    }
    catch(...)
    {
        pStartup->bError = true;
        ::SetEvent(pStartup->hEvent1);
        AfxEndThread((UINT)-1,false);
    }
    HANDLE hEvent2 = pStartup->hEvent2;
    ::SetEvent(pStartup->hEvent1);
    ::WaitForSingleObject(hEvent2,INFINITE);
    ::CloseHandle(hEvent2);
    UINT nResult = (*pThread->m_pfnThreadProc)(pThread->m_pThreadParams);
    AfxEndThread(nResult);
    return 0;
}
bool CWinThread::CreateThread(UINT dwStackSize ,DWORD  dwCreateFlags ,LPSECURITY_ATTRIBUTES lpThreadAttributes )
{
    _AFX_THREAD_STARTUP startup ;
    startup.bError = false;
    startup.pThread = this;
    startup.hEvent1 = ::CreateEvent(NULL,true,false,NULL);
    startup.hEvent2 = ::CreateEvent(NULL,true,false,NULL);
    m_hThread = (HANDLE)::_beginthreadex(NULL,0,_AfxThreadEntry,&startup,dwCreateFlags|CREATE_SUSPENDED,&m_uId);
    if(m_hThread == NULL)
    {
        return false;
    }
    ::ResumeThread(m_hThread);
    ::WaitForSingleObject(startup.hEvent1,INFINITE);
    ::CloseHandle(startup.hEvent1);
    if(dwCreateFlags&CREATE_SUSPENDED)
    {
        ::SuspendThread(m_hThread);
    }
    if(startup.bError)
    {
        ::WaitForSingleObject(m_hThread,INFINITE);
        ::CloseHandle(m_hThread);
        m_hThread = NULL;
        ::CloseHandle(startup.hEvent2);
        return false;
    }
    ::SetEvent(startup.hEvent2);
    return true;
}
CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc,LPVOID pParam,
                                        int nPriority ,UINT nStackSize ,
                                        DWORD dwCreateFlags,LPSECURITY_ATTRIBUTES lpSecurityAtts)
{
    CWinThread* pThread = new CWinThread(pfnThreadProc,pParam);
    if(!pThread->CreateThread(nStackSize,dwCreateFlags,lpSecurityAtts))
    {
        pThread->Delete();
        return NULL;
    }
    pThread->SetThreadPriority(nPriority);
    if(!(dwCreateFlags&CREATE_SUSPENDED))
    {
        pThread->ResumeThread();
    }
    return pThread;
}
void AfxEndThread(UINT nExitCode,bool bDelete )
{
    AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
    CWinThread* pThread = pState->m_pCurrentWinThread;
    if(pThread!=NULL)
    {
        if(bDelete)
        {
            pThread->Delete();
        }
        pState->m_pCurrentWinThread = NULL;
    }
    if(_afxThreadData != NULL)
    {
        _afxThreadData->DeleteValues(NULL,false);
    }
    _endthreadex(nExitCode);
}
CWinThread* AfxGetThread()
{
    AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
    return pState->m_pCurrentWinThread;
}
void CWinThread::CommonConstruct()
{
    m_hThread = NULL;
    m_uId = 0;
    m_bAutoDelete = true;
}
CWinThread::CWinThread(AFX_THREADPROC pfnThreadProc,LPVOID pParam)
{
    m_pfnThreadProc = pfnThreadProc;
    m_pThreadParams = pParam;
    CommonConstruct();
}
CWinThread::CWinThread()
{
    m_pfnThreadProc = NULL;
    m_pThreadParams = NULL;
    CommonConstruct();
}
CWinThread::~CWinThread()
{
    if(m_hThread != NULL)
    {
        ::CloseHandle(m_hThread);
    }
    AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
    if(pState->m_pCurrentWinThread == this)
    {
        pState->m_pCurrentWinThread = NULL;
    }
}
void CWinThread::Delete()
{
    if(m_bAutoDelete)
    {
        delete this;
    }
}

Test.cpp:

#include<iostream>
#include"_AFXWIN.h"
using namespace std;
UINT MyFunc(LPVOID lpParam)
{
    printf("Thread Identify:%d 
",AfxGetThread()->m_uId);
    return 0;
}
int main()
{
    for(int i = 0; i<10;i++)
    {
        AfxBeginThread(MyFunc,NULL);
    }
    system("pause");
}

--------------------------------------------分割线-----------------------------------------------------

 

哎哟(￣y▽,￣)╭ ，写了这么长时间的这玩意，也总算是写完了，那么我们从头来讲。

起初，他是需要设计一个可以无限申请TLS索引而又可以动态管理指针单元所指向内存单元的分配和释放的系统。在书中作者的意思是：利用现有的TLS系统，在这个系统基础上再建立一个新的符合上述条件的TLS系统。这样想来，我们可以画出我们这个TLS系统的内存模型图。如下所示：

这样想来其实是很简单的，我们只需要为每个线程的私有存储空间即线程的私有空指针分配一段空指针数组的内存即可，那么我们用的时候，就可以在每个线程中使用不同槽位置的空指针并为其分配内存即可。可是这样就有问题了，第一我们不知道我们为每个线程所分配的这个空指针数组的大小，如果我们约定一个固定的数，比如我们为每个线程都分配32个空指针大小的数组，那么当我们所需要的槽即我们所需要的这些个空指针数目超过32个该怎么办呢？那么如果我们申请一块内存保存这个数，让每个线程的数组大小都保持这么多可以吗？肯定也是不行的！因为假如我们在线程1中用了很多这样的私有内存，而在线程2中没有用到或者用的很少的时候，我们还为线程2分配那么多的内存，岂不是产生了很多的内存浪费？所以这样也不行！那么记录一个数不行，如果我们为每个线程申请一个私有的内存保存这个线程私有数组的大小行不行呢？显然是可以的，这样既保证了对数组大小的无限分配，又保证了内存不会出现大量浪费。那么我们把这个东西保存在哪里呢？显然我们可以把线程私有数组的头指针和这个数字变量保存在一起，合成一个结构体，我们把这个结构体叫做CThreadData。如下：

struct CThreadData

{

int nCount;

LPVOID pData;

};

这样来看的话，我们的内存模型就变成了：

这样解决了上一个问题。可是，我们TLS是需要为每个线程分配空槽，那么我们的哪个槽正在使用中？哪个槽被释放？被占用的槽的占用资源是什么？我们都不知道，可能我们会把已经占用的槽都给分配出去，这显然是不允许的。所以我们还需要为每个槽保存一个结构体，形成一个结构体数组，结构体中包含了上面两者的状态，叫做CSlotData。如下：

struct CSlotData

{

HANDLE hInst;

DWORD dwFlags;

};

这样的话，我们就必须保存这个数组的头指针，由于我们需要的是不定长的结构体数组大小，所以我们还需要一个整型变量来保存这个数组的大小。两个变量结合成一个类CThreadSlotData。如下：

class CThreadSlotData

{

public:

CSlotData* m_pSlotData;

int m_nAlloc;

};

如果我们每次申请新槽都需要重新分配内存，那么显然是不现实的。所以我们最好是一次性分配一定的量，在用完之后，再分配一定的量，如此循环。我们可以再保存一个变量存储已使用过的最大号槽的号数+1，变量叫做m_nRover，这保证了m_nRover号及之后的槽总是可以使用的。这样可以了吗？这时候我们再来想一个问题，假如我们每次为CSlotData数组增加32个位置，那是不是也意味着我们也需要为每个线程的私有数组在新分配32个位置，但如果我们有的线程根本就用不到这么长的数组空间，那岂不是浪费了很多，所以我们再保存一个变量用来存储m_nRover+1，变量名为m_nMax，这样可以保证浪费变得很少。

理论上来讲，这里的m_nMax是和m_nRover相同或大于即可的，但是作者这么写了，我们就也先写这个数。

所以，类代码如下：

class CThreadSlotData

{

public:

CSlotData* m_pSlotData;

int m_nAlloc;

int m_nRover;

int m_nMax;

};

这样来讲的话，我们可以再次画出它的内存模型，如下：

注：CThreadSlotData类图中，为节省图面空间，没有写其他几个成员。

 

想到这里，就有了如上的内存模型图。但是我们的类是为了其功能而创建的，所以我们需要清晰一下它的功能：

 

1.要能够申请槽位和释放槽位。

2.要能够存取我们任意类型的数据。

3.能够在线程结束时释放所有申请的内存。

4.能够自动为我们的数据申请内存并保存。

 

我们把上述功能在聚集到上面所述的类CThreadSlotData中，再加上类本身的构造和析构函数，另外类在申请系统的TLS时，需要保存申请的Index号数，得到如下：

CThreadSlotData

{

public:

CThreadSlotData();

 

int AllocSlot();

void FreeSlot(int nSlot);

void* GetThreadValue(int nSlot);

void SetValue(int nSlot,void* pValue);

 

DWORD m_tlsIndex;

int m_nAlloc;

int m_nRover;

int m_nMax;

CSlotData* m_pSlotData;

~CThreadSlotData();

};

现在我们来想一下，我们如何释放掉所有线程的同一个槽位？

再回看一下上面的内存模型，我们可以做到吗？显然，我们不可能在线程内部释放。所以我们必须有办法在主线程内获取所有其它线程申请的私有内存。这也就是说，我们必须在类中保存一个进入其他线程私有存储的方法，当然，我们也许还可以用一个数组把所有的私有内存地址保存下来，但更好的是，我们将不同线程私有内存的指针用链表连接起来，这样就可以很简单的在主线程里释放槽位了。

当然，现在的问题是，我们如何在这个类里加上链表？我们可以选择直接在类内写一个链表，可是这样这个类太过臃肿，而且代码耦合性会很高，出问题的话很难解决，链表本身和这个类关系要求又不是特别高，有一定通用性，所以更好的办法是：我们封装一个链表类，然后在这个类中声明出来。这样的代码独立性更高，复用性更高，更加所谓“面向对象”。

那么接下来，就是这个链表类CSimpleList:

class CSimpleList

{

public:

CSimpleList(int nNextOffset=0);

void Construct(int nNextOffset);

 

bool IsEmpty() const;

void AddHead(void* p);

void RemoveAll();

void* GetHead() const;

bool Remove(void* p);

 

void* m_pHead;

size_t m_nNextOffset;

void** GetNextPtr(void* p)const;

};

具体实现也就不再讲了，具体这里很多函数为什么声明其实作者也讲地比较清楚了，如果各位还有什么不懂的话，可以联系问我。

接下来是它的模板类CSimpleListTyped。如下：

 

template<class TYPE>

class CTypedSimpleList : public CSimpleList

{

public:

CTypedSimpleList(int nNextOffSet = 0):CSimpleList(nNextOffSet){};

void  AddHead(TYPE p)

{

CSimpleList::AddHead((void*)p);

}

TYPE GetHead() const

{

return (TYPE)CSimpleList::GetHead();

}

bool  Remove(TYPE p)

{

return CSimpleList::Remove((void*)p);

}

TYPE  GetNext(void* p) const

{

return (TYPE)CSimpleList::GetNext(p);

}

operator TYPE()

{

return (TYPE)CSimpleList::GetHead();

}

};

 

这个类出现是为了更好的封装和使用上述链表，这个类中我觉得也并不难，唯一可能大家会不明白的一点就是最后一个函数operator TYPE()了。这个函数是个类类型转换，有关这个大家可以直接百度类类型转换，就会一目了然。如果还有其他的什么，也可以直接问，我就不再赘述了。

有了这个类，我们就可以把线程私有的连接起来，但链表单元也需要有指向下一单元的指针，所以我们需要在线程私有的结构体CThreadData中保存一个这样的指针。于是结构体变成了：

struct CThreadData

{

CThreadData* pNext;

int nCount;

LPVOID pData;

};

接着只需要在类中声明这样一个成员就可以了。

但这样足够了吗？显然还不够，你需要能够释放任一线程任意模块的能力，所以有了如下成员函数：

void DeleteValues(HINSTANCE hInst,bool bAll = false);//删除任意模块，可选是否删除所有线程的

void DeleteValues(CThreadData* pData,HINSTANCE hInst);//删除本线程的任一模块

//以上所有的hInst == NULL的情况都是删除所有的意思。

两个函数嵌套调用即可实现这种能力。

另外，这些线程在执行时，必然会有同时访问同一段内存的情况发生，比如同时添加链表单元。所以，这个类成员还需要保证多线程执行的互锁函数和其相关成员。这样的话，我们再添加上成员:

CRITICAL_SECTION m_cs;

这时候这个类的内存模型就变成了：

接近完美！但还差一点儿。理论上，这个类是可以申请TLS_MINIMUN_AVAILABLE个对象的，但是其实对于这个类来说，一个也就够了，因为其本身可以申请足够多个我们所设计的系统所提供的槽位，所以这是足够的。所以我们直接为其声明为一个全局指针，利用重载new方法，将一段已经声明的全局内存地址传过去，这时候就可以利用new操作符的特性，让这个对象自动调用构造函数构造其本身。至于为什么这么麻烦而不是直接声明一个全局的类对象，原因很简单，因为书上是这么写的，而我是不知道为什么的~~~,,ԾㅂԾ,,~~~。我做了好多实验，个人认为从这个角度上讲是可以直接声明一个类对象的，但作者没这么做，而是绕了一个大圈，如此繁琐实现了这个样子，我想以后的扩展代码也许自有其用途吧。

这样的话，我们把这个运算符重载加上去，类的设计则接近完成。

 

但我们可以直接把这个类给用户使用吗？肯定是不行的。这个类还缺少了为系统槽内指针分配内存的能力，这是其一；其二这个系统本身也是不够坚固，很多函数并不足够健壮，例如系统本身在你不申请到特定槽号的情况下也是可以直接存取那个槽号的槽指针的值的；其三，很扯淡的一个原因，不够面向对象，这样子存取本身和面向过程方法不无区别；其四，若是用户创建很多个这样的类，当数目超过TLS_MINIMUN_AVAILABLE时，就会将系统的所有Tls申请完毕，之后的类对象就不能够在进行使用，造成很多其他困扰。

足够符合上述条件的，最好的是这个类每个对象对应一个槽，这样使用方便，且符合条件三和四，在使用时规范使用这个类，就可以忽略上述健壮性问题，那么最后我们可以用模板类来实现上述的分配内存的问题。这样的话，类CThreadLocalObject和类CThreadLocal完美符合了这个条件。可是假如我们定义了一个CThreadLocal<MyStructData> g_myStructData;那么我们如何访问MyStructData内部的成员呢？这就是CThreadLocal类中 TYPE* operator->(); 运算符重载函数的作用，有关这个运算符重载大家可以看我的其他文章，上面有其他讲的很好的链接，此处不再赘述。

那么前面的内存部分就到此结束了。可是我们这样还不够自动化，我们需要最好是那种线程自动清理的TLS，所以需要把原有的线程开始结束函数等封装一下，让他可以在线程结束时，自动清理所有的东西。

我们需要一个类，用它来管理线程的挂起唤醒设置权限线程创建等功能。这个类要能够保存他所管理的线程的线程句柄以及线程ID。这样想来有了类CWinThread的原型：

class CWinThread

{

public:

CWinThread();

bool CreateThread(DWORD dwCreateFlags = 0,UINT nStackSize = 0,LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);

HANDLE m_hThread;

operator HANDLE() const {return m_hThread;}

DWORD m_nThreadID;

 

int GetThreadPriority();

bool SetThreadPriority(int nPriority);

 

DWORD SuspendThread();

DWORD ResumeThread();

};

但如作者所说，一个线程的维护是还需要其他很多东西的，所以，作者再封装了一个可扩展的类AFX_MODULE_THREAD_STATE。此处不再多写。

那么我们在创建一个线程的时候，怎样才能够检测到线程结束以便于做清理工作呢？当然，我们可以利用事件机制进行通信，这就是后面有关其他函数封装的原理了。后面的很多东西其实作者就讲的比较清楚了，我这里就不再多说了（其实是累死我了不想再写了）。

当然，如果读者有什么问题可以在直接联系我，可以大家一起研究解决问题。

--------------------------------------------分割线-----------------------------------------------------

 

哎哟(￣y▽,￣)╭ ，写了这么长时间的这玩意，也总算是写完了，那么我们从头来讲。

起初，他是需要设计一个可以无限申请TLS索引而又可以动态管理指针单元所指向内存单元的分配和释放的系统。在书中作者的意思是：利用现有的TLS系统，在这个系统基础上再建立一个新的符合上述条件的TLS系统。这样想来，我们可以画出我们这个TLS系统的内存模型图。如下所示：

这样想来其实是很简单的，我们只需要为每个线程的私有存储空间即线程的私有空指针分配一段空指针数组的内存即可，那么我们用的时候，就可以在每个线程中使用不同槽位置的空指针并为其分配内存即可。可是这样就有问题了，第一我们不知道我们为每个线程所分配的这个空指针数组的大小，如果我们约定一个固定的数，比如我们为每个线程都分配32个空指针大小的数组，那么当我们所需要的槽即我们所需要的这些个空指针数目超过32个该怎么办呢？那么如果我们申请一块内存保存这个数，让每个线程的数组大小都保持这么多可以吗？肯定也是不行的！因为假如我们在线程1中用了很多这样的私有内存，而在线程2中没有用到或者用的很少的时候，我们还为线程2分配那么多的内存，岂不是产生了很多的内存浪费？所以这样也不行！那么记录一个数不行，如果我们为每个线程申请一个私有的内存保存这个线程私有数组的大小行不行呢？显然是可以的，这样既保证了对数组大小的无限分配，又保证了内存不会出现大量浪费。那么我们把这个东西保存在哪里呢？显然我们可以把线程私有数组的头指针和这个数字变量保存在一起，合成一个结构体，我们把这个结构体叫做CThreadData。如下：

struct CThreadData

{

int nCount;

LPVOID pData;

};

这样来看的话，我们的内存模型就变成了：

这样解决了上一个问题。可是，我们TLS是需要为每个线程分配空槽，那么我们的哪个槽正在使用中？哪个槽被释放？被占用的槽的占用资源是什么？我们都不知道，可能我们会把已经占用的槽都给分配出去，这显然是不允许的。所以我们还需要为每个槽保存一个结构体，形成一个结构体数组，结构体中包含了上面两者的状态，叫做CSlotData。如下：

struct CSlotData

{

HANDLE hInst;

DWORD dwFlags;

};

这样的话，我们就必须保存这个数组的头指针，由于我们需要的是不定长的结构体数组大小，所以我们还需要一个整型变量来保存这个数组的大小。两个变量结合成一个类CThreadSlotData。如下：

class CThreadSlotData

{

public:

CSlotData* m_pSlotData;

int m_nAlloc;

};

如果我们每次申请新槽都需要重新分配内存，那么显然是不现实的。所以我们最好是一次性分配一定的量，在用完之后，再分配一定的量，如此循环。我们可以再保存一个变量存储已使用过的最大号槽的号数+1，变量叫做m_nRover，这保证了m_nRover号及之后的槽总是可以使用的。这样可以了吗？这时候我们再来想一个问题，假如我们每次为CSlotData数组增加32个位置，那是不是也意味着我们也需要为每个线程的私有数组在新分配32个位置，但如果我们有的线程根本就用不到这么长的数组空间，那岂不是浪费了很多，所以我们再保存一个变量用来存储m_nRover+1，变量名为m_nMax，这样可以保证浪费变得很少。

理论上来讲，这里的m_nMax是和m_nRover相同或大于即可的，但是作者这么写了，我们就也先写这个数。

所以，类代码如下：

class CThreadSlotData

{

public:

CSlotData* m_pSlotData;

int m_nAlloc;

int m_nRover;

int m_nMax;

};

这样来讲的话，我们可以再次画出它的内存模型，如下：

注：CThreadSlotData类图中，为节省图面空间，没有写其他几个成员。

 

想到这里，就有了如上的内存模型图。但是我们的类是为了其功能而创建的，所以我们需要清晰一下它的功能：

 

1.要能够申请槽位和释放槽位。

2.要能够存取我们任意类型的数据。

3.能够在线程结束时释放所有申请的内存。

4.能够自动为我们的数据申请内存并保存。

 

我们把上述功能在聚集到上面所述的类CThreadSlotData中，再加上类本身的构造和析构函数，另外类在申请系统的TLS时，需要保存申请的Index号数，得到如下：

CThreadSlotData

{

public:

CThreadSlotData();

 

int AllocSlot();

void FreeSlot(int nSlot);

void* GetThreadValue(int nSlot);

void SetValue(int nSlot,void* pValue);

 

DWORD m_tlsIndex;

int m_nAlloc;

int m_nRover;

int m_nMax;

CSlotData* m_pSlotData;

~CThreadSlotData();

};

现在我们来想一下，我们如何释放掉所有线程的同一个槽位？

再回看一下上面的内存模型，我们可以做到吗？显然，我们不可能在线程内部释放。所以我们必须有办法在主线程内获取所有其它线程申请的私有内存。这也就是说，我们必须在类中保存一个进入其他线程私有存储的方法，当然，我们也许还可以用一个数组把所有的私有内存地址保存下来，但更好的是，我们将不同线程私有内存的指针用链表连接起来，这样就可以很简单的在主线程里释放槽位了。

当然，现在的问题是，我们如何在这个类里加上链表？我们可以选择直接在类内写一个链表，可是这样这个类太过臃肿，而且代码耦合性会很高，出问题的话很难解决，链表本身和这个类关系要求又不是特别高，有一定通用性，所以更好的办法是：我们封装一个链表类，然后在这个类中声明出来。这样的代码独立性更高，复用性更高，更加所谓“面向对象”。

那么接下来，就是这个链表类CSimpleList:

class CSimpleList

{

public:

CSimpleList(int nNextOffset=0);

void Construct(int nNextOffset);

 

bool IsEmpty() const;

void AddHead(void* p);

void RemoveAll();

void* GetHead() const;

bool Remove(void* p);

 

void* m_pHead;

size_t m_nNextOffset;

void** GetNextPtr(void* p)const;

};

具体实现也就不再讲了，具体这里很多函数为什么声明其实作者也讲地比较清楚了，如果各位还有什么不懂的话，可以联系问我。

接下来是它的模板类CSimpleListTyped。如下：

 

template<class TYPE>

class CTypedSimpleList : public CSimpleList

{

public:

CTypedSimpleList(int nNextOffSet = 0):CSimpleList(nNextOffSet){};

void  AddHead(TYPE p)

{

CSimpleList::AddHead((void*)p);

}

TYPE GetHead() const

{

return (TYPE)CSimpleList::GetHead();

}

bool  Remove(TYPE p)

{

return CSimpleList::Remove((void*)p);

}

TYPE  GetNext(void* p) const

{

return (TYPE)CSimpleList::GetNext(p);

}

operator TYPE()

{

return (TYPE)CSimpleList::GetHead();

}

};

 

这个类出现是为了更好的封装和使用上述链表，这个类中我觉得也并不难，唯一可能大家会不明白的一点就是最后一个函数operator TYPE()了。这个函数是个类类型转换，有关这个大家可以直接百度类类型转换，就会一目了然。如果还有其他的什么，也可以直接问，我就不再赘述了。

有了这个类，我们就可以把线程私有的连接起来，但链表单元也需要有指向下一单元的指针，所以我们需要在线程私有的结构体CThreadData中保存一个这样的指针。于是结构体变成了：

struct CThreadData

{

CThreadData* pNext;

int nCount;

LPVOID pData;

};

接着只需要在类中声明这样一个成员就可以了。

但这样足够了吗？显然还不够，你需要能够释放任一线程任意模块的能力，所以有了如下成员函数：

void DeleteValues(HINSTANCE hInst,bool bAll = false);//删除任意模块，可选是否删除所有线程的

void DeleteValues(CThreadData* pData,HINSTANCE hInst);//删除本线程的任一模块

//以上所有的hInst == NULL的情况都是删除所有的意思。

两个函数嵌套调用即可实现这种能力。

另外，这些线程在执行时，必然会有同时访问同一段内存的情况发生，比如同时添加链表单元。所以，这个类成员还需要保证多线程执行的互锁函数和其相关成员。这样的话，我们再添加上成员:

CRITICAL_SECTION m_cs;

这时候这个类的内存模型就变成了：

接近完美！但还差一点儿。理论上，这个类是可以申请TLS_MINIMUN_AVAILABLE个对象的，但是其实对于这个类来说，一个也就够了，因为其本身可以申请足够多个我们所设计的系统所提供的槽位，所以这是足够的。所以我们直接为其声明为一个全局指针，利用重载new方法，将一段已经声明的全局内存地址传过去，这时候就可以利用new操作符的特性，让这个对象自动调用构造函数构造其本身。至于为什么这么麻烦而不是直接声明一个全局的类对象，原因很简单，因为书上是这么写的，而我是不知道为什么的~~~,,ԾㅂԾ,,~~~。我做了好多实验，个人认为从这个角度上讲是可以直接声明一个类对象的，但作者没这么做，而是绕了一个大圈，如此繁琐实现了这个样子，我想以后的扩展代码也许自有其用途吧。

这样的话，我们把这个运算符重载加上去，类的设计则接近完成。

 

但我们可以直接把这个类给用户使用吗？肯定是不行的。这个类还缺少了为系统槽内指针分配内存的能力，这是其一；其二这个系统本身也是不够坚固，很多函数并不足够健壮，例如系统本身在你不申请到特定槽号的情况下也是可以直接存取那个槽号的槽指针的值的；其三，很扯淡的一个原因，不够面向对象，这样子存取本身和面向过程方法不无区别；其四，若是用户创建很多个这样的类，当数目超过TLS_MINIMUN_AVAILABLE时，就会将系统的所有Tls申请完毕，之后的类对象就不能够在进行使用，造成很多其他困扰。

足够符合上述条件的，最好的是这个类每个对象对应一个槽，这样使用方便，且符合条件三和四，在使用时规范使用这个类，就可以忽略上述健壮性问题，那么最后我们可以用模板类来实现上述的分配内存的问题。这样的话，类CThreadLocalObject和类CThreadLocal完美符合了这个条件。可是假如我们定义了一个CThreadLocal<MyStructData> g_myStructData;那么我们如何访问MyStructData内部的成员呢？这就是CThreadLocal类中 TYPE* operator->(); 运算符重载函数的作用，有关这个运算符重载大家可以看我的其他文章，上面有其他讲的很好的链接，此处不再赘述。

那么前面的内存部分就到此结束了。可是我们这样还不够自动化，我们需要最好是那种线程自动清理的TLS，所以需要把原有的线程开始结束函数等封装一下，让他可以在线程结束时，自动清理所有的东西。

我们需要一个类，用它来管理线程的挂起唤醒设置权限线程创建等功能。这个类要能够保存他所管理的线程的线程句柄以及线程ID。这样想来有了类CWinThread的原型：

class CWinThread

{

public:

CWinThread();

bool CreateThread(DWORD dwCreateFlags = 0,UINT nStackSize = 0,LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);

HANDLE m_hThread;

operator HANDLE() const {return m_hThread;}

DWORD m_nThreadID;

 

int GetThreadPriority();

bool SetThreadPriority(int nPriority);

 

DWORD SuspendThread();

DWORD ResumeThread();

};

但如作者所说，一个线程的维护是还需要其他很多东西的，所以，作者再封装了一个可扩展的类AFX_MODULE_THREAD_STATE。此处不再多写。

那么我们在创建一个线程的时候，怎样才能够检测到线程结束以便于做清理工作呢？当然，我们可以利用事件机制进行通信，这就是后面有关其他函数封装的原理了。后面的很多东西其实作者就讲的比较清楚了，我这里就不再多说了（其实是累死我了不想再写了）。

当然，如果读者有什么问题可以在直接联系我，可以大家一起研究解决问题。