[置顶] 关于线程局部存储代码出错分析讨论

忙了一两天把这个代码敲完了,但是在调试时候出 了一些问题,慕思苦想还没搞定这个问题多以请大家指点指点



_AFXTLS.h文件如下:

/******************************************************************* 

 *  Copyright(c) 2000-2016 Company Name 

 *  All rights reserved. 

 *   

 *  文件名称: _AFXTLS.h

 *  简要描述: 

 *   

 *  创建日期: 2016.6.30

 *  作者: 

 *  说明: 

 ******************************************************************/  

#ifndef __AFXTLS_H__

#define __AFXTLS_H__

#include "stdafx.h"

#include "windows.h"

#include <rpcndr.h>

#define offsetof(s,m) (size_t)&(((s*)0)->m)

#define SLOT_USED 0x01

// --------CSimpList - provide a simple function------------------

class CSimpList

{

public:
~CSimpList();
void **GetNextPtr(void *p) const
{
return  (void **)((BYTE*)p+m_nNextOffset);
}
CSimpList(int nNextOffSet = 0);
void Construct(int nNextOffSet);
BOOL IsEmpty()const;
void AddHead(void *p);
void RemoveAll();
void* GetHead()const;
void *GetNext(void *p)const;
BOOL Remove(void *p);

private:
void *m_pHead;//指向链表第一个位置
size_t m_nNextOffset;//数据结构中pNext成员的偏移量

};

inline CSimpList::CSimpList(int nNextOffSet)

{
m_pHead = NULL;
this->m_nNextOffset = nNextOffSet;

}

inline CSimpList::~CSimpList()

{

}

inline void CSimpList::Construct(int nNextOffSet)

{
this->m_nNextOffset = nNextOffSet;

}

inline BOOL CSimpList::IsEmpty() const

{
return m_pHead ==NULL;

}

inline void CSimpList::RemoveAll()

{
m_pHead =NULL;

}

inline void* CSimpList::GetHead() const

{
return m_pHead;

}

inline void * CSimpList::GetNext(void *p) const

{
return GetNextPtr(p);

}

inline BOOL CSimpList::Remove(void *p)

{
if (m_pHead == NULL)
{
return FALSE;
}
bool bResult = FALSE;
if(p == m_pHead)
{
m_pHead  = *GetNextPtr(p);
bResult = true;
}
else
{
void *pTest = m_pHead;
while (pTest !=NULL && *GetNextPtr(pTest)!=p)
{
pTest = *GetNextPtr(p);
}
if(pTest !=NULL)
{
*GetNextPtr(pTest) = *GetNextPtr(p);
bResult = true;
}
}
return bResult;

}

inline void CSimpList::AddHead(void *p)

{
*GetNextPtr(p)=m_pHead;
m_pHead = p;

}

// --------CTypedSimpleList - extend CSimpleList------------------

template<class TYPE>

class CTypedSimpleList:public CSimpList

{

public:
CTypedSimpleList(int nNextOffSet = 0): CSimpList(nNextOffSet){}
void AddHead(TYPE p)
{
CSimpList::AddHead((void *)p);
}
TYPE GetHead()
{
return (TYPE)CSimpList::GetHead();
}
TYPE GetNext(TYPE p)
{
return (TYPE)CSimpList::GetNext(p);
}
BOOL Remove(TYPE p)
{
return CSimpList::Remove(p);
}

/*
CTypeSimpleList <CThreadData *>list
CThreadData *pData = list;等价于pData = list.GetHead
*/
operator TYPE()//直接引用类的对象会调用此函数
{
return  (TYPE)CSimpList::GetHead();
}

};

// --------CNoTrackObject --------------------------------------------

class CNoTrackObject //负责私有线程低层内存分配

{

public:
void *operator new(size_t nSize);
void operator delete(void *p);
virtual ~CNoTrackObject();

};

struct CThreadData :public CNoTrackObject  
//线程的私有数据

{
CThreadData *pNext;//指向下一个结构指针
LPVOID
*Data; //真正指向的数据
int nCount;
// current size of pData

};

// --------CSlotData --------------------------------------------

struct CSlotData

{
DWORD dwflag;
//槽的使用标志,使用或未使用
HINSTANCE hInst;

};

// --------CThreadSlotData --------------------------------------------

class CThreadSlotData

{

public:
CThreadSlotData();
~CThreadSlotData();
int AllocSlot();//分配槽
void FreeSlot(int nSlot);//释放槽
void *GetThreadValue(int nSlot);
void SetValue(int nSlot,void *pValue);
void DeleteValue(HINSTANCE hinst,BOOL bAll =FALSE);
DWORD m_tlsIndex;
CTypedSimpleList <CThreadData *> m_list;
int m_nAlloc;
//m_pSlotData所指向的数组大小
int m_nMax;
//占用槽的最大数
CSlotData * m_pSlotdata;//全局数组的首地址
int m_nRover;
//为了快速找到空闲的槽而设定的值
CRITICAL_SECTION m_cs;
void *operator new (size_t,void *p)
{
return p;
}
void DeleteValues(CThreadData *pData,HINSTANCE hinst);

};

class CThreadLocalObject

{

public:
CThreadLocalObject();
~CThreadLocalObject();
//属性成员,用于取得保存在线程局部的变量中的指针
CNoTrackObject * GetData(CNoTrackObject* (*pfnCreateObject)());
CNoTrackObject * GetDataNA();//返回变量的值

//具体实现
DWORD m_nSlot;

};

template <class TYPE>

class CThreadLocal:public CThreadLocalObject

{
public:
TYPE *GetData()
{
TYPE *pData = (TYPE *)CThreadLocalObject::GetData(&CreateObject);
return pData;
}
TYPE GetDataNA()
{
TYPE *pData = (TYPE *)CThreadLocalObject::GetDataNA();
return pData;
}
operator TYPE*()
{
return GetData();
}
TYPE* operator->()
{
return GetData();
}

static CNoTrackObject* CreateObject()
{
return new TYPE;
}

};

#endif

_AFXTLS.cpp文件如下:

#include "stdafx.h"

#include "_AFXTLS.h"

#include "windows.h"

#include <winbase.h>

void *CNoTrackObject::operator new(size_t nSize)

{
void *p = ::GlobalAlloc(GPTR,nSize);
return p;

}

void CNoTrackObject::operator delete(void *p)

{
::GlobalFree(p);

}

CNoTrackObject::~CNoTrackObject()

{

}

CThreadSlotData::CThreadSlotData()

{
m_list.Construct(offsetof(CThreadData,pNext));
m_nMax = 0;
m_nAlloc = 0;
m_nRover = 1;
//假设SLOT1还未分配,Slot0总是被保留
m_pSlotdata = NULL;//指向槽的指针
m_tlsIndex = ::TlsAlloc();
::InitializeCriticalSection(&m_cs);

}

int CThreadSlotData::AllocSlot()

{
::EnterCriticalSection(&m_cs);

int nAlloc = m_nAlloc;
int nSlot = m_nRover;
if (nSlot>=nAlloc || m_pSlotdata[nSlot].dwflag & SLOT_USED)
{
for (nSlot = 1;nSlot<nAlloc && m_pSlotdata[nSlot].dwflag & SLOT_USED;nSlot++)
{
//如果不存在空槽申请更多的空间
int  nNewAlloc =nAlloc+32;
HGLOBAL hSlotData;
if (m_pSlotdata  == NULL)
{
hSlotData = ::GlobalAlloc(GMEM_MOVEABLE,nNewAlloc * sizeof(CSlotData));
}
else
{
hSlotData = ::GlobalHandle(m_pSlotdata);
::GlobalUnlock(hSlotData);
hSlotData = GlobalReAlloc(hSlotData,nNewAlloc * sizeof(CSlotData),GMEM_MOVEABLE);
}
CSlotData *pSlotData = (CSlotData*)GlobalLock(hSlotData);
m_nAlloc  = nNewAlloc;
m_pSlotdata = pSlotData;

}
}
if(nSlot >= m_nMax)
{
m_nMax = nSlot+1;
}
m_pSlotdata[nSlot].dwflag |=SLOT_USED;//标志为该标记已经使用
m_nRover = nSlot+1;//更新m_nRover假设下一个槽未被使用
::LeaveCriticalSection(&m_cs);

return nSlot;

}

BYTE __afxThreadData[sizeof CThreadData]; //为下面的__afxThreadData变量提供内存

CThreadSlotData *_afxThreadData; //定义全局变量__afxThreadData来为全局变量分配内存

void CThreadSlotData::SetValue(int nSlot,void *pValue)

{
CThreadData *pData = (CThreadData* )::TlsGetValue(m_tlsIndex);//通过tls索引为线程分配私有空间
//为线程私有数据分配空间
if((pData ==NULL || nSlot>=pData->nCount)&& pValue !=NULL)
{
if (pData ==NULL)
{
pData = new CThreadData;
pData->nCount = 0;
pData->Data = NULL;

//将新申请的内存地址添加到全局变量中
::EnterCriticalSection(&m_cs);
m_list.AddHead(pData);
::LeaveCriticalSection(&m_cs);
}

//pData->data 指向真正的线程私有数据
//下面的代码将私有的数据占用的空间增长到m_nMax指定的大小
if (pData->Data ==NULL)
{
pData->Data =(void **) GlobalAlloc(LMEM_FIXED,m_nMax*sizeof(LPVOID));
} 
else
{
pData->Data = (void **)::GlobalReAlloc(pData->Data,m_nMax*sizeof(LPVOID),LMEM_MOVEABLE);
}

//将申请的内存初始化为0;
memset(&(pData->Data) + pData->nCount,0,(m_nMax-pData->nCount)*sizeof(LPVOID));
pData->nCount=m_nMax;
::TlsSetValue(m_tlsIndex,pData);
}
pData->Data[nSlot] = pValue;

}

void *CThreadSlotData::GetThreadValue(int nSlot)

{
CThreadData *pData=(CThreadData *)TlsGetValue(m_tlsIndex);
if (pData==NULL || nSlot>=pData->nCount)
{
return NULL;
}
return pData->Data[nSlot];

}

void CThreadSlotData:: FreeSlot(int nSlot)

{
::EnterCriticalSection(&m_cs);
CThreadData *pData = m_list;
while (pData !=NULL)
{
if (nSlot<pData->nCount)
{
delete((CNoTrackObject*)pData->Data[nSlot]);
pData->Data[nSlot] = NULL;
pData = pData->pNext;
}

}
//将此槽标示为未被使用
m_pSlotdata[nSlot].dwflag &=~SLOT_USED;
::LeaveCriticalSection(&m_cs);

}

void CThreadSlotData::DeleteValue(HINSTANCE hinst,BOOL bAll /*=FALSE*/)

{
::EnterCriticalSection(&m_cs);
if (!bAll)
{
//仅仅删除当前线程的线程局部存储占用空间
CThreadData *pData=(CThreadData*)TlsGetValue(m_tlsIndex);
if (pData !=NULL)
{
DeleteValues(pData,hinst);
}
else
{
//删除所有线程的线程局部存储占用的空间
CThreadData *pData = m_list.GetHead();
while (pData !=NULL)
{
CThreadData *pNextData = pData->pNext;
DeleteValues(pData,hinst);
pData = pNextData;
}
}

}
::LeaveCriticalSection(&m_cs);

}

void CThreadSlotData::DeleteValues(CThreadData *pData,HINSTANCE hinst)

{
//释放表中每一个元素
BOOL bDelete = TRUE;
for (int i = 1;i<pData->nCount;i++)
{
if (hinst ==NULL || m_pSlotdata[i].hInst ==hinst)
{
//hinst匹配,删除数据
delete((CNoTrackObject*)pData->Data[i]);
pData->Data[i] = NULL;
} 
else
{
//还有其他模块在使用不要删除数据
if(pData->Data[i]!=NULL)
bDelete =FALSE;
}
if (bDelete)
{
//从列表中删除
::EnterCriticalSection(&m_cs);
m_list.Remove(pData);
::LeaveCriticalSection(&m_cs);
::LocalFree(pData->Data);
delete pData;
//清除TLS索引以免重用
::TlsSetValue(m_tlsIndex,NULL);
}
}

}

CThreadSlotData::~CThreadSlotData()

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

}

CThreadLocalObject::CThreadLocalObject()

{

}

CThreadLocalObject::~CThreadLocalObject()

{
if (m_nSlot!=0 &&_afxThreadData!=NULL)
{
_afxThreadData->FreeSlot(m_nSlot);
m_nSlot = 0;
}

}

CNoTrackObject * CThreadLocalObject::GetData(CNoTrackObject* (*pfnCreateObject)())

{
if (m_nSlot = NULL)
{
if (_afxThreadData = NULL)
{
_afxThreadData = new(__afxThreadData)CThreadSlotData;
m_nSlot = _afxThreadData->AllocSlot();
}
}
CNoTrackObject *pValue = (CNoTrackObject*)_afxThreadData->GetThreadValue(m_nSlot);
if (pValue==NULL)
{
pValue = (*pfnCreateObject)();
_afxThreadData->SetValue(m_nSlot,pValue);
}
return pValue;

}

CNoTrackObject * CThreadLocalObject::GetDataNA()

{
if (m_nSlot == 0||_afxThreadData == 0)
{
return NULL;
}
return (CNoTrackObject*)_afxThreadData->GetThreadValue(m_nSlot);

}

主文件TLS.cpp文件如下:

// TLS.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include "windows.h"

#include "_AFXTLS.h"

#include "process.h"

#pragma comment(lib,"ws2_32.lib")

void ShowData();

struct CMyThreadData:public CNoTrackObject

{
int nSomeData;

};

CThreadLocal<CMyThreadData>g_myThreadData;

UINT __stdcall ThreadFunc(LPVOID lpParam)

{
g_myThreadData->nSomeData =(int)lpParam;
ShowData();
return 0;

}

int _tmain(int argc, _TCHAR* argv[])\

{

HANDLE h[10];
UINT uID;

for (int i =0;i<10;i++)
h[i] =(HANDLE) _beginthreadex(NULL,0,ThreadFunc,(void *)i,0,&uID);
::WaitForMultipleObjects(10,h,TRUE,INFINITE);
for (int i=0;i<10;i++)
{
::CloseHandle(h[i]);
}

}

void ShowData()

{
int nData = g_myThreadData->nSomeData;
printf("Thread ID:%-5d,nSomeData = %d\n",::GetCurrentThreadId(),nData);

}