本文深入解析C/C++运行库中的_mtinit函数，详细介绍其如何为多线程环境准备必要的资源，包括初始化锁机制和分配线程本地数据结构。通过分析源代码，揭示了_mtinit如何确保标准库函数在多线程环境下正确执行。
紧接上文，来看看另外一个函数_mtinit,这个函数定义在tidtable.c文件中
/****
*_mtinit() - Init multi-thread data bases
*
*Purpose:
* (1) Call _mtinitlocks to create/open all lock semaphores.
* (2) Allocate a TLS index to hold pointers to per-thread data
* structure.
*
* NOTES:
* (1) Only to be called ONCE at startup
* (2) Must be called BEFORE any mthread requests are made
*
*Entry:
* <NONE>
*Exit:
* returns FALSE on failure
*
*Uses:
* <any registers may be modified at init time>
*
*Exceptions:
*
*******************************************************************************/
int __cdecl _mtinit (
void
)
{
_ptiddata ptd; /_tiddata结构体的指针
#ifdef _M_IX86
/*
* Initialize fiber local storage function pointers.
*/
HINSTANCE hKernel32 = GetModuleHandleW(L"KERNEL32.DLL");
if (hKernel32 == NULL) {
_mtterm();
return FALSE; /* fail to load DLL */
}
gpFlsAlloc = (PFLS_ALLOC_FUNCTION)GetProcAddress(hKernel32,
"FlsAlloc");
gpFlsGetValue = (PFLS_GETVALUE_FUNCTION)GetProcAddress(hKernel32,
"FlsGetValue");
gpFlsSetValue = (PFLS_SETVALUE_FUNCTION)GetProcAddress(hKernel32,
"FlsSetValue");
gpFlsFree = (PFLS_FREE_FUNCTION)GetProcAddress(hKernel32,
"FlsFree");
if (!gpFlsAlloc || !gpFlsGetValue || !gpFlsSetValue || !gpFlsFree) {
gpFlsAlloc = (PFLS_ALLOC_FUNCTION)__crtTlsAlloc;
gpFlsGetValue = (PFLS_GETVALUE_FUNCTION)TlsGetValue;
gpFlsSetValue = (PFLS_SETVALUE_FUNCTION)TlsSetValue;
gpFlsFree = (PFLS_FREE_FUNCTION)TlsFree;
}
//填充这几个全局函数指针 Fls系列是纤程的局部储存函数，区别于线程局部储存Tls系列
/*
* Allocate and initialize a TLS index to store FlsGetValue pointer
* so that the FLS_* macros can work transparently
*/
if ( (__getvalueindex = TlsAlloc()) == TLS_OUT_OF_INDEXES ||
!TlsSetValue(__getvalueindex, (LPVOID)gpFlsGetValue) ) {
return FALSE; //初始化全局线程局部标识__getvalueindex，用来标识FlsGetValue函数的指针
}
#endif /* _M_IX86 */
_init_pointers(); /* initialize global function pointers */ 初始化一些全局函数的指针
#ifdef _M_IX86
/*
* Encode the fiber local storage function pointers
*/
gpFlsAlloc = (PFLS_ALLOC_FUNCTION) EncodePointer(gpFlsAlloc);
gpFlsGetValue = (PFLS_GETVALUE_FUNCTION) EncodePointer(gpFlsGetValue);
gpFlsSetValue = (PFLS_SETVALUE_FUNCTION) EncodePointer(gpFlsSetValue);
gpFlsFree = (PFLS_FREE_FUNCTION) EncodePointer(gpFlsFree); //对函数指针加密
#endif /* _M_IX86 */
/*
* Initialize the mthread lock data base
*/
if ( !_mtinitlocks() ) {
_mtterm();
return FALSE; /* fail to load DLL */ 初始化多线程同步时用到的一个结构
}
/*
* Allocate a TLS index to maintain pointers to per-thread data
*/
if ( (__flsindex = FLS_ALLOC(&_freefls)) == FLS_OUT_OF_INDEXES ) {
_mtterm();
return FALSE; /* fail to load DLL */ //__flsindex是一个全局的线程局部储存标识，标识每个线程的tiddate
}
/*
* Create a per-thread data structure for this (i.e., the startup)
* thread.
*/
if ( ((ptd = _calloc_crt(1, sizeof(struct _tiddata))) == NULL) ||
!FLS_SETVALUE(__flsindex, (LPVOID)ptd) ) //为tiddate结构分配对空间
{
_mtterm();
return FALSE; /* fail to load DLL */
}
/*
* Initialize the per-thread data
*/
_initptd(ptd,NULL); //初始化tiddate结构
ptd->_tid = GetCurrentThreadId();
ptd->_thandle = (uintptr_t)(-1);
return TRUE;
}
从该函数的注释看这个函数主要做了两方面的工作
* (1) Call _mtinitlocks to create/open all lock semaphores.
* (2) Allocate a TLS index to hold pointers to per-thread data
* structure.2、分配一个线程局部索引标记，为每个线程存储一个_tiddate结构体，该结构体同样是为C/C++标准库函数在多线程环境下工作提供支持，一些函数的实现中，用每个线程的_tiddate结构中的数据来当做全局变量工作。
首先 _ptiddata ptd;这里是一个结构体的指针 typedef struct _tiddata * _ptiddata;
_tiddata是一个在crt中很重要的结构体，每个程序的主线程以及使用_beginthreadex来启动的线程都默认拥有这样一个结构体，通过线程本地储存来保存它的指针
他定义在mtdll.h文件中
/* Structure for each thread's data */
struct _tiddata {
unsigned long _tid; /* thread ID */
uintptr_t _thandle; /* thread handle */
int _terrno; /* errno value */
unsigned long _tdoserrno; /* _doserrno value */
unsigned int _fpds; /* Floating Point data segment */
unsigned long _holdrand; /* rand() seed value */
char * _token; /* ptr to strtok() token */
wchar_t * _wtoken; /* ptr to wcstok() token */
unsigned char * _mtoken; /* ptr to _mbstok() token */
/* following pointers get malloc'd at runtime */
char * _errmsg; /* ptr to strerror()/_strerror() buff */
wchar_t * _werrmsg; /* ptr to _wcserror()/__wcserror() buff */
char * _namebuf0; /* ptr to tmpnam() buffer */
wchar_t * _wnamebuf0; /* ptr to _wtmpnam() buffer */
char * _namebuf1; /* ptr to tmpfile() buffer */
wchar_t * _wnamebuf1; /* ptr to _wtmpfile() buffer */
char * _asctimebuf; /* ptr to asctime() buffer */
wchar_t * _wasctimebuf; /* ptr to _wasctime() buffer */
void * _gmtimebuf; /* ptr to gmtime() structure */
char * _cvtbuf; /* ptr to ecvt()/fcvt buffer */
unsigned char _con_ch_buf[MB_LEN_MAX];
/* ptr to putch() buffer */
unsigned short _ch_buf_used; /* if the _con_ch_buf is used */
/* following fields are needed by _beginthread code */
void * _initaddr; /* initial user thread address */
void * _initarg; /* initial user thread argument */
/* following three fields are needed to support signal handling and
* runtime errors */
void * _pxcptacttab; /* ptr to exception-action table */
void * _tpxcptinfoptrs; /* ptr to exception info pointers */
int _tfpecode; /* float point exception code */
/* pointer to the copy of the multibyte character information used by
* the thread */
pthreadmbcinfo ptmbcinfo;
/* pointer to the copy of the locale informaton used by the thead */
pthreadlocinfo ptlocinfo;
int _ownlocale; /* if 1, this thread owns its own locale */
/* following field is needed by NLG routines */
unsigned long _NLG_dwCode;
/*
* Per-Thread data needed by C++ Exception Handling
*/
void * _terminate; /* terminate() routine */
void * _unexpected; /* unexpected() routine */
void * _translator; /* S.E. translator */
void * _purecall; /* called when pure virtual happens */
void * _curexception; /* current exception */
void * _curcontext; /* current exception context */
int _ProcessingThrow; /* for uncaught_exception */
void * _curexcspec; /* for handling exceptions thrown from std::unexpected */
#if defined (_M_IA64) || defined (_M_AMD64)
void * _pExitContext;
void * _pUnwindContext;
void * _pFrameInfoChain;
unsigned __int64 _ImageBase;
#if defined (_M_IA64)
unsigned __int64 _TargetGp;
#endif /* defined (_M_IA64) */
unsigned __int64 _ThrowImageBase;
void * _pForeignException;
#elif defined (_M_IX86)
void * _pFrameInfoChain;
#endif /* defined (_M_IX86) */
_setloc_struct _setloc_data;
void * _reserved1; /* nothing */
void * _reserved2; /* nothing */
void * _reserved3; /* nothing */
#ifdef _M_IX86
void * _reserved4; /* nothing */
void * _reserved5; /* nothing */
#endif /* _M_IX86 */
int _cxxReThrow; /* Set to True if it's a rethrown C++ Exception */
unsigned long __initDomain; /* initial domain used by _beginthread[ex] for managed function */
};
typedef struct _tiddata * _ptiddata;
都有英文注释，不翻译了
这个结构体的阐述放到后面
下面开始一点一点的来看_mtinit 做了哪些工作
首先 初始化纤程本地存储 相关的几个函数指针
gpFlsAlloc gpFlsGetValue gpFlsSetValue gpFlsFree 因为这一系列函数在VISTA 和Server 2003及之后才支持，因此定义了在宏#ifdef _M_IX86内，在32位系统中从kernel32.dll中动态获取函数地址，并且加密该函数指针
gpFlsAlloc = (PFLS_ALLOC_FUNCTION) EncodePointer(gpFlsAlloc);
gpFlsGetValue = (PFLS_GETVALUE_FUNCTION) EncodePointer(gpFlsGetValue);
gpFlsSetValue = (PFLS_SETVALUE_FUNCTION) EncodePointer(gpFlsSetValue);
gpFlsFree = (PFLS_FREE_FUNCTION) EncodePointer(gpFlsFree); #ifdef _M_IX86
extern PFLS_ALLOC_FUNCTION gpFlsAlloc;
extern PFLS_GETVALUE_FUNCTION gpFlsGetValue;
extern PFLS_SETVALUE_FUNCTION gpFlsSetValue;
extern PFLS_FREE_FUNCTION gpFlsFree;
#define FLS_ALLOC(callback) (((PFLS_ALLOC_FUNCTION) DecodePointer(gpFlsAlloc))(callback))
#define FLS_GETVALUE ((PFLS_GETVALUE_FUNCTION)TlsGetValue(__getvalueindex))
#define FLS_SETVALUE(index, value) (((PFLS_SETVALUE_FUNCTION) DecodePointer(gpFlsSetValue))(index, value))
#define FLS_FREE(index) (((PFLS_FREE_FUNCTION) DecodePointer(gpFlsFree))(index))
#else /* _M_IX86 */
#define FLS_ALLOC(callback) FlsAlloc(callback)
#define FLS_GETVALUE(index) FlsGetValue(index)
#define FLS_SETVALUE(index, value) FlsSetValue(index, value)
#define FLS_FREE(index) FlsFree(index)当32位编译模式的时候 解密函数指针并调用，在64位模式时候直接调用Kernel32.dll导出的接口
然后是
_init_pointers(); /* initialize global function pointers */ 初始化一些全局函数的指针该函数定义在crt0dat.c文件中
void __cdecl _init_pointers() {
void *enull = _encoded_null();
_initp_heap_handler(enull);
_initp_misc_invarg(enull);
_initp_misc_purevirt(enull);
_initp_misc_rand_s(enull);
_initp_misc_winsig(enull);
_initp_eh_hooks(enull);
}_CRTIMP void * __cdecl _encoded_null()
{
return EncodePointer(NULL); //返回一个对NULL的加密表示空的函数指针
}
1、_initp_heap_handler(enull); 定义在handler.cpp文件中
/* pointer to old-style C++ new handler */
_PNH _pnhHeap; //typedef int (__clrcall * _PNH)( size_t );一个函数指针
/***
*_initp_heap_handler()
*
*Purpose:
*
*******************************************************************************/
extern "C"
void __cdecl _initp_heap_handler(void *enull)
{
_pnhHeap = (_PNH) enull;
}
2、_initp_misc_invarg(enull); 定义在invarg.c文件中
/* global variable which stores the user handler */
_invalid_parameter_handler __pInvalidArgHandler; //typedef void (__cdecl *_invalid_parameter_handler)(const wchar_t *, const wchar_t *, const wchar_t *, unsigned int, uintptr_t);
extern "C"
void _initp_misc_invarg(void* enull)
{
__pInvalidArgHandler = (_invalid_parameter_handler) enull;
}__pInvalidArgHandler函数指针，这里初始化为空加密，它的作用是当传递给一个CRT函数无效的参数时被调用，这个函数指针可以由 _set_invalid_parameter_handler 来设置，
3、 _initp_misc_purevirt(enull); 在inithelp.c文件中定义
_purecall_handler __pPurecall= NULL;
/***
*void _initp_misc_purevirt(void) -
*
*Purpose:
* Initialize the __pPurecall function pointer
*
*Entry:
* The per-process encoded value for the null pointer.
*
*Exit:
* Never returns
*
*Exceptions:
*
*******************************************************************************/
//extern "C"
void __cdecl _initp_misc_purevirt(void* enull)
{
__pPurecall = (_purecall_handler) enull;
}__pPurecall全局函数指针，它的作用是当调用一个纯虚函数时候被触发，这个指针可以通过_set_purecall_handler来设置成我们自己的函数过程
4、 _initp_misc_rand_s(enull); 在Rand_s.c文件中定义
typedef BOOL (APIENTRY *PGENRANDOM)( PVOID, ULONG );
static PGENRANDOM g_pfnRtlGenRandom;
void __cdecl _initp_misc_rand_s(void* enull)
{
g_pfnRtlGenRandom = (PGENRANDOM) enull;
}g_pfnRtlGenRandom 全局函数指针，它的作用是返回一个无符号的随机整数，这个指针在rand_s函数中被替换为ADVAPI32.DLL导出的RtlGenRandom函数，参考MSDN 中rand_s函数的使用
5、_initp_misc_winsig(enull); 定义在Winsig.c文件中
/*
* variables holding action codes (and code pointers) for SIGINT, SIGBRK,
* SIGABRT and SIGTERM.
*
* note that the disposition (i.e., action to be taken upon receipt) of
* these signals is defined on a per-process basis (not per-thread)!!
*/
static _PHNDLR ctrlc_action = SIG_DFL; /* SIGINT */
static _PHNDLR ctrlbreak_action = SIG_DFL; /* SIGBREAK */
static _PHNDLR abort_action = SIG_DFL; /* SIGABRT */
static _PHNDLR term_action = SIG_DFL; /* SIGTERM */
void __cdecl _initp_misc_winsig(void* enull)
{
ctrlc_action = (_PHNDLR) enull; /* SIGINT */
ctrlbreak_action = (_PHNDLR) enull; /* SIGBREAK */
abort_action = (_PHNDLR) enull; /* SIGABRT */
term_action = (_PHNDLR) enull; /* SIGTERM */
}
6、_initp_eh_hooks 没有找这个函数的实现
紧接着是
if ( !_mtinitlocks() ) {
_mtterm();
return FALSE; /* fail to load DLL */
}/***
*_mtinitlocks() - Initialize multi-thread lock scheme
*
*Purpose:
* Perform whatever initialization is required for the multi-thread
* locking (synchronization) scheme. This routine should be called
* exactly once, during startup, and this must be before any requests
* are made to assert locks.
*
* NOTES: In Win32, the multi-thread locks are created individually,
* each upon its first use. That is when any particular lock is asserted
* for the first time, the underlying critical section is then allocated,
* initialized and (finally) entered. This allocation and initialization
* is protected under _LOCKTAB_LOCK. It is _mtinitlocks' job to set up
* _LOCKTAB_LOCK.
*
* All other named (non-FILE) locks are also preallocated in _mtinitlocks.
* That is because a failure to allocate a lock on its first use in _lock
* triggers a fatal error, which cannot be permitted since that can bring
* down a long-lived app without warning.
*
*Entry:
* <none>
*
*Exit:
* returns FALSE on failure
*
*Exceptions:
*
*******************************************************************************/
int __cdecl _mtinitlocks (
void
)
{
int locknum;
int idxPrealloc = 0;
/*
* Scan _locktable[] and allocate all entries marked lkPrealloc.
*/
for ( locknum = 0 ; locknum < _TOTAL_LOCKS ; locknum++ ) {
if ( _locktable[locknum].kind == lkPrealloc ) {
_locktable[locknum].lock = &lclcritsects[idxPrealloc++];
if ( !InitializeCriticalSectionAndSpinCount( _locktable[locknum].lock,
_CRT_SPINCOUNT ))
{
_locktable[locknum].lock = NULL;
return FALSE;
}
}
}
return TRUE;
}
这里引用到了两个全局的静态数组_locktable和 lclcritsects,
#define NUM_STD_FILE_LOCKS 3
/*
* _DEBUG_LOCK is preallocated in _DEBUG & not in Retail
*/
#ifdef _DEBUG
#define NUM_NON_PREALLOC_LOCKS 4
#else /* _DEBUG */
#define NUM_NON_PREALLOC_LOCKS 5
#endif /* _DEBUG */
#define NUM_PREALLOC_LOCKS \
( _STREAM_LOCKS + NUM_STD_FILE_LOCKS - NUM_NON_PREALLOC_LOCKS )
static CRITICAL_SECTION lclcritsects[NUM_PREALLOC_LOCKS];
/*
* Lock Table
* This table contains a pointer to the critical section management structure
* for each lock.
*
* Locks marked lkPrealloc have their critical sections statically allocated
* and initialized at startup in _mtinitlocks. Locks marked lkNormal must
* be allocated when first used, via a call to _mtinitlocknum.
*/
static struct {
PCRITICAL_SECTION lock;
enum { lkNormal = 0, lkPrealloc, lkDeleted } kind;
} _locktable[_TOTAL_LOCKS] = {
{ NULL, lkPrealloc }, /* 0 == _SIGNAL_LOCK */
{ NULL, lkPrealloc }, /* 1 == _IOB_SCAN_LOCK */
{ NULL, lkNormal }, /* 2 == _TMPNAM_LOCK - not preallocated */
{ NULL, lkPrealloc }, /* 3 == _CONIO_LOCK */
{ NULL, lkPrealloc }, /* 4 == _HEAP_LOCK */
{ NULL, lkNormal }, /* 5 == _UNDNAME_LOCK - not preallocated */
{ NULL, lkPrealloc }, /* 6 == _TIME_LOCK */
{ NULL, lkPrealloc }, /* 7 == _ENV_LOCK */
{ NULL, lkPrealloc }, /* 8 == _EXIT_LOCK1 */
{ NULL, lkNormal }, /* 9 == _POPEN_LOCK - not preallocated */
{ NULL, lkPrealloc }, /* 10 == _LOCKTAB_LOCK */
{ NULL, lkNormal }, /* 11 == _OSFHND_LOCK - not preallocated */
{ NULL, lkPrealloc }, /* 12 == _SETLOCALE_LOCK */
{ NULL, lkPrealloc }, /* 13 == _MB_CP_LOCK */
{ NULL, lkPrealloc }, /* 14 == _TYPEINFO_LOCK */
#ifdef _DEBUG
{ NULL, lkPrealloc }, /* 15 == _DEBUG_LOCK */
#else /* _DEBUG */
{ NULL, lkNormal }, /* 15 == _DEBUG_LOCK */
#endif /* _DEBUG */
{ NULL, lkPrealloc }, /* 16 == _STREAM_LOCKS+0 - stdin */
{ NULL, lkPrealloc }, /* 17 == _STREAM_LOCKS+1 - stdout */
{ NULL, lkPrealloc }, /* 18 == _STREAM_LOCKS+2 - stderr */
/* { NULL, lkNormal }, /* ... */
};可以看到_locktable 是个结构体数组，该类型的结构体有一个临界区对象指针PCRITICAL_SECTION lock;，和一个枚举型变量enum { lkNormal = 0, lkPrealloc, lkDeleted } kind构成。lclcritsects则是一个CRITICAL_SECTION临界区对象数组，该数组的大小为NUM_PREALLOC_LOCKS
#define NUM_PREALLOC_LOCKS \
( _STREAM_LOCKS + NUM_STD_FILE_LOCKS - NUM_NON_PREALLOC_LOCKS )
#define _STREAM_LOCKS 16 /* Table of stream locks */
#define NUM_STD_FILE_LOCKS 3
#ifdef _DEBUG
#define NUM_NON_PREALLOC_LOCKS 4
#else /* _DEBUG */
#define NUM_NON_PREALLOC_LOCKS 5
#endif /* _DEBUG */
在Debug模式下是15 在release下是14 刚好和 _locktable 数组中 枚举量为lkPrealloc的元素数目相等。根据结构体的说 lkNormal类型的在第一次使用时为其分配内存，而lkPrealloc则在程序启动的时候为其分配内存并初始化
for ( locknum = 0 ; locknum < _TOTAL_LOCKS ; locknum++ ) {
if ( _locktable[locknum].kind == lkPrealloc ) {
_locktable[locknum].lock = &lclcritsects[idxPrealloc++]; //将类型为lpPrealloc类型的，让指针指向clcritsects数组对应的元素
if ( !InitializeCriticalSectionAndSpinCount( _locktable[locknum].lock,// 用InitializeCriticalSectionAndSpinCount初始化该临界区对象
_CRT_SPINCOUNT )) //_CRT_SPINCOUNT 的值为4000
{
_locktable[locknum].lock = NULL;
return FALSE;
}
}
}
InitializeCriticalSectionAndSpinCount 跟InitializeCriticalSection的区别在于，前者在尝试获取临街区代码控制权时有个数量的循环尝试过程，每次占用很少的CPU时钟周期，在循环完毕后才进入线程休眠状态，而后者如果获取不到权限直接进入休眠，线程休眠耗用的CPU时钟周期很大，因此在很轻量级的互斥中，如对单个全局变量的访问时，选择前者更为效率。
这个18临界区对象都有各自的用处，他们通过_lock和_unlock两个接口函数来使用
***
* _lock - Acquire a multi-thread lock
*
*Purpose:
* Acquire a multi-thread lock. If the lock has not already been
* allocated, do so, but that is an internal CRT error, since all locks
* should be allocated before first being acquired, either in
* _mtinitlocks or individually in _mtinitlocknum.
*
* Note that it is legal for a thread to aquire _EXIT_LOCK1
* multiple times.
*
*Entry:
* locknum = number of the lock to aquire
*
*Exit:
*
*Exceptions:
* A failure to allocate a new lock results in a fatal _RT_LOCK error.
*
*******************************************************************************/
void __cdecl _lock (
int locknum
)
{
/*
* Create/open the lock, if necessary
*/
if ( _locktable[locknum].lock == NULL ) {
if ( !_mtinitlocknum(locknum) )
_amsg_exit( _RT_LOCK );
}
/*
* Enter the critical section.
*/
EnterCriticalSection( _locktable[locknum].lock );
}
/***
* _unlock - Release multi-thread lock
*
*Purpose:
* Note that it is legal for a thread to aquire _EXIT_LOCK1
* multiple times.
*
*Entry:
* locknum = number of the lock to release
*
*Exit:
*
*Exceptions:
*
*******************************************************************************/
void __cdecl _unlock (
int locknum
)
{
/*
* leave the critical section.
*/
LeaveCriticalSection( _locktable[locknum].lock );
}#define _mlock(l) _lock(l)在Mtdll.h文件中定义了 访问每个临界区对象对应的宏
#define _SIGNAL_LOCK 0 /* lock for signal() */
#define _IOB_SCAN_LOCK 1 /* _iob[] table lock */
#define _TMPNAM_LOCK 2 /* lock global tempnam variables */
#define _CONIO_LOCK 3 /* lock for conio routines */
#define _HEAP_LOCK 4 /* lock for heap allocator routines */
#define _UNDNAME_LOCK 5 /* lock for unDName() routine */
#define _TIME_LOCK 6 /* lock for time functions */
#define _ENV_LOCK 7 /* lock for environment variables */
#define _EXIT_LOCK1 8 /* lock #1 for exit code */
#define _POPEN_LOCK 9 /* lock for _popen/_pclose database */
#define _LOCKTAB_LOCK 10 /* lock to protect semaphore lock table */
#define _OSFHND_LOCK 11 /* lock to protect _osfhnd array */
#define _SETLOCALE_LOCK 12 /* lock for locale handles, etc. */
#define _MB_CP_LOCK 13 /* lock for multibyte code page */
#define _TYPEINFO_LOCK 14 /* lock for type_info access */
#define _DEBUG_LOCK 15 /* lock for debug global structs */
#define _STREAM_LOCKS 16 /* Table of stream locks */这些临界区对象，为C运行库函数的多线程支持提供了，防止代码重入对一些静态及全家数据的访问的破坏。
再往下是
if ( (__flsindex = FLS_ALLOC(&_freefls)) == FLS_OUT_OF_INDEXES ) {
_mtterm();
return FALSE; /* fail to load DLL */
}
这里FLS_ALLOC就是前面提到的宏 在32位下 调用全家函数指针gpFlsAlloc 在64位下调用FlsAlloc, 这个函数在MSDN中是这样说明的
DWORD WINAPI FlsAlloc( __in PFLS_CALLBACK_FUNCTION lpCallback );
-
lpCallback [in]
-
A pointer to the application-defined callback function of type PFLS_CALLBACK_FUNCTION. This parameter is optional. For more information, seeFlsCallback.
_CRTIMP void
WINAPI
_freefls (
void *data
)
{
_ptiddata ptd;
pthreadlocinfo ptloci;
pthreadmbcinfo ptmbci;
/*
* Free up the _tiddata structure & its malloc-ed buffers.
*/
ptd = data;
if (ptd != NULL) {
if(ptd->_errmsg)
_free_crt((void *)ptd->_errmsg);
if(ptd->_namebuf0)
_free_crt((void *)ptd->_namebuf0);
if(ptd->_namebuf1)
_free_crt((void *)ptd->_namebuf1);
if(ptd->_asctimebuf)
_free_crt((void *)ptd->_asctimebuf);
if(ptd->_wasctimebuf)
_free_crt((void *)ptd->_wasctimebuf);
if(ptd->_gmtimebuf)
_free_crt((void *)ptd->_gmtimebuf);
if(ptd->_cvtbuf)
_free_crt((void *)ptd->_cvtbuf);
if (ptd->_pxcptacttab != _XcptActTab)
_free_crt((void *)ptd->_pxcptacttab);
_mlock(_MB_CP_LOCK);
__try {
if ( ((ptmbci = ptd->ptmbcinfo) != NULL) &&
(InterlockedDecrement(&(ptmbci->refcount)) == 0) &&
(ptmbci != &__initialmbcinfo) )
_free_crt(ptmbci);
}
__finally {
_munlock(_MB_CP_LOCK);
}
_mlock(_SETLOCALE_LOCK);
__try {
if ( (ptloci = ptd->ptlocinfo) != NULL )
{
__removelocaleref(ptloci);
if ( (ptloci != __ptlocinfo) &&
(ptloci != &__initiallocinfo) &&
(ptloci->refcount == 0) )
__freetlocinfo(ptloci);
}
}
__finally {
_munlock(_SETLOCALE_LOCK);
}
_free_crt((void *)ptd);
}
return;
看以看到 这里_freefls 用来清理释放为线程分配的_tiddate结构。
__flsindex = FLS_ALLOC(&_freefls)) == FLS_OUT_OF_INDEXES
这里FLS_OUT_OF_INDEXES 是一个宏标识 没有分配到索引号，而__flsindex 是一个全局变量来表示FlsAlloc分配的索引号，每个线程的_tiddate结构，在堆中分配内存，然后初始化后通过/!FLS_SETVALUE(__flsindex, (LPVOID)ptd) )将结构体指针保存到 局部储存中去。
再往下是：
if ( ((ptd = _calloc_crt(1, sizeof(struct _tiddata))) == NULL) ||
!FLS_SETVALUE(__flsindex, (LPVOID)ptd) )
{
_mtterm();
return FALSE; /* fail to load DLL */
}
_calloc_crt 这里为_tiddata结构在堆中分配内存，紧接着_initptd(ptd,NULL); 初始化分配到的结构体空间
/***
*void _initptd(_ptiddata ptd, pthreadlocinfo) - initialize a per-thread data structure
*
*Purpose:
* This routine handles all of the per-thread initialization
* which is common to _beginthread, _beginthreadex, _mtinit
* and _getptd.
*
*Entry:
* pointer to a per-thread data block
*
*Exit:
* the common fields in that block are initialized
*
*Exceptions:
*
*******************************************************************************/
_CRTIMP void __cdecl _initptd (
_ptiddata ptd,
pthreadlocinfo ptloci
)
{
#ifdef _M_IX86
HINSTANCE hKernel32 = GetModuleHandleW(L"KERNEL32.DLL");
#endif /* _M_IX86 */
ptd->_pxcptacttab = (void *)_XcptActTab; //一个异常表，用于控制台信号实现
ptd->_terrno = 0; //每个线程有自己的错误返回码
ptd->_holdrand = 1L;
// It is necessary to always have GLOBAL_LOCALE_BIT set in perthread data
// because when doing bitwise or, we won't get __UPDATE_LOCALE to work when
// global per thread locale is set.
ptd->_ownlocale = _GLOBAL_LOCALE_BIT;
// Initialize _setloc_data. These are the only valuse that need to be
// initialized.
ptd->_setloc_data._cachein[0]='C';
ptd->_setloc_data._cacheout[0]='C'; //本地化相关
ptd->ptmbcinfo = &__initialmbcinfo; //字符相关
_mlock(_MB_CP_LOCK);
__try
{
InterlockedIncrement(&(ptd->ptmbcinfo->refcount));
}
__finally
{
_munlock(_MB_CP_LOCK);
}
// We need to make sure that ptd->ptlocinfo in never NULL, this saves us
// perf counts when UPDATING locale.
_mlock(_SETLOCALE_LOCK);
__try {
ptd->ptlocinfo = ptloci;
/*
* Note that and caller to _initptd could have passed __ptlocinfo, but
* that will be a bug as between the call to _initptd and __addlocaleref
* the global locale may have changed and ptloci may be pointing to invalid
* memory. Thus if the wants to set the locale to global, NULL should
* be passed.
*/
if (ptd->ptlocinfo == NULL)
ptd->ptlocinfo = __ptlocinfo;
__addlocaleref(ptd->ptlocinfo);
}
__finally {
_munlock(_SETLOCALE_LOCK);
}
}最后
ptd->_tid = GetCurrentThreadId(); 设置线程ID
ptd->_thandle = (uintptr_t)(-1); 线程句柄设成-1
关于多线程更多参见http://blog.youkuaiyun.com/wangpengk7788/article/details/53938288
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
