TLS

转载： 

今天看到线程局部存储,人民邮电出版社的这本<WINDOWS程序设计>上面关于TLS描述的不是很细致, 多个线程访问共享数据，需要昂贵的同步开销，也容易造成同步相关的BUG。 

线程局部存储在不同的平台有不同的实现，可移植性不太好。幸好要实现线程局部存储并不难，最简单的办法就是建立一个全局表，通过当前线程ID去查询相应的数据，因为各个线程的ID不同，查到的数据自然也不同了。 
大多数平台都提供了线程局部存储的方法，无需要我们自己去实现： 

尽管像青蛙一样的两栖动物绝不会比人类更高级，但能适应于更多环境的能力毕竟有它的优势。技术也是如此， 

共享内存和线程局部存储就是实例，它们是为了防止走向内存完全隔离和完全共享两个极端的产物。 


动态线程局部存储 

TLS技术可应用于应用程序也可用于DLL。TLS的目的就是将数据与特定的线程相关联。 



进程中的线程是通过使用一个数组来保存与线程相关联的数据的，这个数组由TLS_MINIMUM_AVAILABLE个元素组成，在WINNT.H文件中该值被定义为64个。也就是说当线程创建时，系统给每一个线程分配了一个数组，这个数组共有TLS_MINIMUM_AVAILABLE个元素，并且将这个数组的各个元素初始化为0，之后系统把这个数组与新创建的线程关联起来。每一个线程中都有它自己的数组，数组中的每一个元素都能保存一个32位的值。在使用这个数组前首先要判定，数组中哪个元素可以使用，这将使用函数TlsAlloc来判断。函数TlsAlloc判断数组中一个元素可用后，就把这个元素分配给调用的线程，并保留给调用线程。要为数组中的某个元素赋值可以使用函数TlsSetValue，要得到某个元素的值可以使用TlsGetValue。下面说明一下各个函数： 

1.DWORD TlsAlloc(VOID);//注意：TlsAlloc函数在返回前会遍历进程中所有的线程，并在新分配的索引处，把每一个线程的数组元素设置为0。 
举例子如下： 

Copy code

#include<iostream> 
#include<string> 

using namespace std; 

#include<windows.h> 

int main() 
{ 
DWORD dwTlsIndex; 

LPVOID lpvSomeValue; 

dwTlsIndex = TlsAlloc(); 

TlsSetValue(dwTlsIndex,(LPVOID)12345); 

lpvSomeValue = TlsGetValue(dwTlsIndex);//此时lpvSomeValue值为12345 

cout<<"第一次的值为："<<lpvSomeValue<<endl; 

dwTlsIndex = TlsAlloc(); 

lpvSomeValue = TlsGetValue(dwTlsIndex);//此时lpvSomeValue的值为0 

cout<<"第二次的值为："<<lpvSomeValue<<endl; 

return 0; 
}　 

VC运行的结果为:
和注解的值不一样,我不是很理解,大牛解释下啊~
2.BOOL TlsSetValue(DWORD dwTlsIndex,LPVOID lpvTlsValue); 
参数说明：dwTlsIndex必须是由TlsAlloc返回的。 
3.LPVOID TlsGetValue(DWORD dwTlsIndex); 
4.BOOL TlsFree(DWORD dwTlsIndex); 
这几个函数都是与调用线程相关联的，也就是说这几个函数在执行时，它只操作调用线程的数组。 
下面举例子说明一下如何使用这几个函数： 

Copy code

DWORD g_dwTlsIndex; 

//该函数实现把结构LPSOMESTRUCT的指针赋给线程的数组中某个元素 

Void myFunction(LPSOMESTRUCT lpSomeStruct){ 

If (lpSomeStruct != NULL){//首先判断结构中是否有数据 

If (TlsGetValue(g_dwTlsIndex) == NULL){//判断数组中索引g_dwTlsIndex处保存的数据是否为NULL，如果为空则在进程的地址空间中分配一块大小为sizeof(lpSomeStruct)的堆，之后将数组中元素指向堆，也就是说元素保存的是指向堆的指针 

TlsSetValue(g_dwTlsIndex, 

HeapAlloc(GetProcessHeap(),0,sizeof(*lpSomeStruct))); 

} 

//将结构中的数据保存到指针TlsGetValue(g_dwTlsIndex)处 

memcpy(TlsGetValue(g_dwTlsIndex),lpSomeStruct, 

sizeof(*lpSomeStruct)); 

//memcpy(目标地址指针1,源地址指针2,长度); 

}else{ 

lpSomeStruct = (LPSOMESTRUCT)TlsGetValue(g_dwTlsIndex); 

} 

} 

14.2 静态线程的局部存储 

使用静态的TLS，不必调用任何函数，如下所示：比如让进程中的每一个线程都关联一个开始时间，那么可以这样做： 

declspec(thread) DWORD gt_dwStartTime = 0;//declspec(thread)告诉编译器，它后面的变量应当放在EXE或DLL相应的tls节中。该变量必须被声明为全局变量或函数（或外部）内部静态变量。 

静态线程TLS的工作方式：当应用程序被装入内存时，系统查看EXE文件中的.tls节，动态地分配了一块能够装下所有静态TLS变量的内存。当程序中的代码要访问一个TLS变量时，该引用被导向分配的内存块中的某一个位置。如果进程新创建了一个线程，系统捕获它，并自动分配一块内存来装下新线程的静态TLS变量，新线程只能访问自己的静态TLS变量，而不能访问其它线程的静态TLS变量。 

静态TLS的缺点：系统允许含有静态TLS变量的DLL被显式的动态载入，但是此时TLS数据并未被初始化，任何对它的访问都会造成错误。动态TLS无此缺点。 

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 
共享内存与线程局部存储 

当我们发明了MMU时，大家认为天下太平了，各个进程空间独立，互不影响，程序的稳定性将大提高。但马上又认识到，进程完全隔离也不行，因为各个进程之间需要信息共享。于是就搞出一种称为共享内存的东西。 

当我们发明了线程的时，大家认为这下可爽了，线程可以并发执行，创建和切换的开销相对进程来说小多了。线程之间的内存是共享的，线程间通信快捷又方便。但马上又认识到，有些信息还是不共享为好，应该让各个线程保留一点隐私。于是就搞出一个线程局部存储的玩意儿。 

共享内存和线程局部存储是两个重要又不常用的东西，平时很少用，但有时候又离不了它们。本文介绍将两者的概念、原理和使用方法，把它们放在自己的工具箱里，以供不时之需。 

1. 共享内存 
大家都知道进程空间是独立的，它们之间互不影响。比如同是0xabcd1234地址的内存，在不同的进程中，它们的数据是不同的，没有关系的。这样做的好处很多：每个进程的地址空间变大了，它们独占4G(32位)的地址空间，让编程实现更容易。各个进程空间独立，一个进程死掉了，不会影响其它进程，提高了系统的稳定性。 

要做到进程空间独立，光靠软件是难以实现的，通常要依赖于硬件的帮助。这种硬件通常称为MMU(Memory Manage Unit)，即所谓的内存管理单元。在这种体系结构下，内存分为物理内存和 

虚拟内存两种。物理内存就是实际的内存，你机器上装了多大内存就有多大内存。而应用程序中使用的是虚拟内存，访问内存数据时，由MMU根据页表把虚拟内存地址转换对应的物理内存地址。 

MMU把各个进程的虚拟内存映射到不同的物理内存上，这样就保证了进程的虚拟内存是独立的。然而，物理内存往往远远少于各个进程的虚拟内存的总和。怎么办呢，通常的办法是把暂时不用的内存写到磁盘上去，要用的时候再加载回内存中来。一般会搞一个专门的分区保存内存数据，这就是所谓的交换分区。 

这些工作由内核配合MMU硬件完成，内存管理是 
[color=#0000cc]操作系统内核的重要功能。其中为了优化性能，使用了不少高级技术，所以内存管理通常比较复杂。比如：在决定把什么数据换出到磁盘上时，采用最近最少使用的策略，把常用的内存数据放在物理内存中，把不常用的写到磁盘上，这种策略的假设是最近最少使用的内存在将来也很少使用。在创建进程时使用COW(Copy on Write)的技术，大大减少了内存数据的复制。为了提高从虚拟地址到物理地址的转换速度，硬件通常采用TLB技术，把刚转换的地址存在 
[color=#0000cc]ca 

che里，下次可以直接使用。 

从虚拟内存到物理内存的映射并不是一个字节一个字节映射的，而是以一个称为页(page)最小单位的为基础的，页的大小视硬件平台而定，通常是4K。当应用程序访问的内存所在页面不在物理内存中时，MMU产生一个缺页中断，并挂起当前进程，缺页中断负责把相应的数据从磁盘读入内存中，再唤醒挂起的进程。 

进程的虚拟内存与物理内存映射关系如下图所示(灰色页为被不在物理内存中的页):

也许我们很少直接使用共享内存，实际上除非性能上有特殊要求，我更愿意采用socket或者管道作为进程间通信的方式。但我们常常间接的使用共享内存，大家都知道共享库（或称为动态库）的优点是，多个应用程序可以公用。如果每个应用程序都加载一份共享库到内存中，显然太浪费了。所以操作系统把共享库放在共享内存中，让多个应用程序共享。另外，同一个应用程序运行多个实例时，也采用同样的方式，保证内存中只有一份可执行代码。这样的共享内存是设为只读属性的，防止应用程序无意中破坏它们。当调试器要设置断点时，相应的页面被拷贝一分，设置为可写的，再向其中写入断点指令。这些事情完全由操作系统等底层软件处理了，应用程序本身无需关心。 

共享内存是怎么实现的呢？我们来看看下图(黄色页为共享内存)： 

由上图可见，实现共享内存非常容易，只是把两个进程的虚拟内存映射同一块物理内存就行了。不过要注意，物理内存相同而虚拟地址却不一定相同，如图中所示进程1的page5和进程2的page2都映射到物理内存的page1上。 

如何在程序中使用共享内存呢？通常很简单，操作系统或者函数库提供了一些 
AP 
I给我们使用。如： 


Linux 

: 
void * mmap(void *start, size_t length, int 

pro 

t , int flags, int fd, off_t offset); 
int munmap(void *start, size_t length);BOOL UnmapV 

ie 

wOfFile( LPCVOID lpBaseA 

ddr 

ess // starting address); 

2. 线程局部存储(TLS) 
同一个进程中的多个线程，它们的内存空间是共享的（栈除外），在一个线程修改的内存内容，对所有线程都生效。这是一个优点也是一个缺点。说它是优点，线程的数据交换变得非常快捷。说它是缺点，一个线程死掉了，其它线程也性命不保; 多个线程访问共享数据，需要昂贵的同步开销，也容易造成同步相关的BUG;。 

在 
unix 
int pthread_key_delete(pthread_key_t key); 
void *pthread_get 

spec 

ific(pthread_key_t key); 
int pthread_setspecific(pthread_key_t key, const void *value); 
Win32 
方法一： 
DWORD TlsAlloc(VOID); 
BOOL TlsFree( 
DWORD dwTlsIndex // TLS index 
); 
BOOL TlsSetValue( 
DWORD dwTlsIndex, // TLS index 
LPVOID lpTlsValue // value to store 
); 
LPVOID TlsGetValue( 
DWORD dwTlsIndex // TLS index 
); 
方法二： 
__declspec( thread ) int tls_i = 1; 

-------------------------------------------------------------