TLS相关探索心得

TLS是什么呢？Thread Local Storage（线程本地存储），TLS 是一个机制，经过它，程序可以拥有全局变量，但处于“每一线程各不相同”的状态。也就是说，进程中的所有线程都可以拥有全局变量，但这些变量其实是特定对某个线程才有意义，各个线程拥有全局变量的一个副本，各自之间不相影响。

 

      就是这么一个意思，比如我定义了一个全局变量  int a=10，那么我在线程1中对a进行操作a=a-1，如果我没用TLS，那么线程2开始获得的a就是9。而如果采取了TLS，不管线程1中对a进行了如何的修改操作，其他的线程一开始获得的a还是10，不会修改。这个全局的变量a是没有存储在线程堆栈中的，是在全局的堆栈中，但是却被各个线程“共享”且互不影响

使用TLS，你需要如下4个API: TlsAlloc、TlsGetValue、TlsSetValue 和 TlsFree。

 

      使用了TLS后，当有新的线程对象诞生，系统就会给该线程分配一个区块，TLS中每一个线程的限制是64的DWORD。也就是你在各个线程之间最多“共享”64个全局DWORD的值，不过，这也是绝对够用了。

 

      一旦线程结束，程序代码就释放所有配置来的区块。我们可以从结构TDB中看到，每一个thread database 都有64 个DWORDs 给TLS 使用。当你以TLS 函式设定或取出数据，事实上你真正面对的就是那64 DWORDs。KERNEL32 使用两个DWORDs（总共64 个位）队列来记录哪一个DWORD 是可用的、哪一个DWORD已经被用。这两个DWORDs 可想象成为两个DWORD数组，合起来供64 位。

 

 

（1）TlsAlloc  

     上面我们说过了KERNEL32 使用两个DWORDs（总共64 个位）来记录哪一个DWORD是可用的、哪一个DWORD 已经被用。当你需要使用一个TLS slot 的时候，你就可以用这个函数将相应的TLS slot位置１。  

 

（2）TlsSetValue  

      TlsSetValue 可以把数据放入先前配置到的TLS slot 中。两个参数分别是TLS slot 索引值以及欲写入的数据内容。TlsSetValue 就把你指定的数据放入64 DWORDs 所组成的数组（位于目前的thread database）的适当位置中。  

 

（3）TlsGetValue  

      这个函数几乎是TlsSetValue 的一面镜子，最大的差异是它取出数据而非设定数据。和TlsSetValue 一样，这个函数也是先检查TLS 索引值合法与否。如果是，TlsGetValue 就使用这个索引值找到64 DWORDs 数组（位于thread database 中）的对应数据项，并将其内容传回。  

 

（4）TlsFree  

      这个函数将TlsAlloc 和TlsSetValue 的努力全部抹消掉。TlsFree 先检验你交给它的索引值是否的确被配置过。如果是，它将对应的64 位TLS slots 位关闭。然后，为了避免那个已经不再合法的内容被使用，TlsFree 巡访进程中的每一个线程，把0 放到刚刚被释放的那个TLS slot 上头。于是呢，如果有某个TLS 索引后来又被重新配置，所有用到该索引的线程就保证会取回一个0 值，除非它们再调用TlsSetValue。

 

如下是MSDN上的一个例子《Using Thread Local Storage

》。

 

[cpp]  view plain copy

1. #include <windows.h>   
2.   
3. #include <stdio.h>   
4.   
5. #define THREADCOUNT 4   
6.   
7. DWORD dwTlsIndex;   
8.   
9. VOID ErrorExit(LPSTR);   
10.   
11.    
12.   
13. VOID CommonFunc(VOID)   
14.   
15. {   
16.   
17.    LPVOID lpvData;   
18.   
19.    
20.   
21. // Retrieve a data pointer for the current thread.   
22.   
23.    
24.   
25.    lpvData = TlsGetValue(dwTlsIndex);   
26.   
27.    if ((lpvData == 0) && (GetLastError() != ERROR_SUCCESS))   
28.   
29.       ErrorExit("TlsGetValue error");   
30.   
31.    
32.   
33. // Use the data stored for the current thread.   
34.   
35.    
36.   
37.    printf("common: thread %d: lpvData=%lx/n",   
38.   
39.       GetCurrentThreadId(), lpvData);   
40.   
41.    
42.   
43.    Sleep(5000);   
44.   
45. }   
46.   
47.    
48.   
49. DWORD WINAPI ThreadFunc(VOID)   
50.   
51. {   
52.   
53.    LPVOID lpvData;   
54.   
55.    
56.   
57. // Initialize the TLS index for this thread.   
58.   
59.    
60.   
61.    lpvData = (LPVOID) LocalAlloc(LPTR, 256);   
62.   
63.    if (! TlsSetValue(dwTlsIndex, lpvData))   
64.   
65.       ErrorExit("TlsSetValue error");   
66.   
67.    
68.   
69.    printf("thread %d: lpvData=%lx/n", GetCurrentThreadId(), lpvData);   
70.   
71.    
72.   
73.    CommonFunc();   
74.   
75.    
76.   
77. // Release the dynamic memory before the thread returns.   
78.   
79.    
80.   
81.    lpvData = TlsGetValue(dwTlsIndex);   
82.   
83.    if (lpvData != 0)   
84.   
85.       LocalFree((HLOCAL) lpvData);   
86.   
87.    
88.   
89.    return 0;   
90.   
91. }   
92.   
93.    
94.   
95. int main(VOID)   
96.   
97. {   
98.   
99.    DWORD IDThread;   
100.   
101.    HANDLE hThread[THREADCOUNT];   
102.   
103.    int i;   
104.   
105.    
106.   
107. // Allocate a TLS index.   
108.   
109.    
110.   
111.    if ((dwTlsIndex = TlsAlloc()) == TLS_OUT_OF_INDEXES)   
112.   
113.       ErrorExit("TlsAlloc failed");   
114.   
115.    
116.   
117. // Create multiple threads.   
118.   
119.    
120.   
121.    for (i = 0; i < THREADCOUNT; i++)   
122.   
123.    {   
124.   
125.       hThread[i] = CreateThread(NULL, // default security attributes   
126.   
127.          0,                           // use default stack size   
128.   
129.          (LPTHREAD_START_ROUTINE) ThreadFunc, // thread function   
130.   
131.          NULL,                    // no thread function argument   
132.   
133.          0,                       // use default creation flags   
134.   
135.          &IDThread);              // returns thread identifier   
136.   
137.    
138.   
139.    // Check the return value for success.   
140.   
141.       if (hThread[i] == NULL)   
142.   
143.          ErrorExit("CreateThread error/n");   
144.   
145.    }   
146.   
147.    
148.   
149.    for (i = 0; i < THREADCOUNT; i++)   
150.   
151.       WaitForSingleObject(hThread[i], INFINITE);   
152.   
153.    
154.   
155.    TlsFree(dwTlsIndex);  
156.   
157.    
158.   
159.    return 0;   
160.   
161. }   
162.   
163.    
164.   
165. VOID ErrorExit (LPSTR lpszMessage)   
166.   
167. {   
168.   
169.    fprintf(stderr, "%s/n", lpszMessage);   
170.   
171.    ExitProcess(0);   
172.   
173. }  

  

 

既然每个线程都有自己的私有堆栈，那么还要整个TLS做什么？线程的私用数据全放堆栈里不就得了？有人会这样疑问？

我们来看一段伪代码：

 

 

[cpp]  view plain copy

1. int a=100;   
2.   
3.    
4.   
5. CreateThread(ThreadProc,NULL);   
6.   
7.    
8.   
9. void ThreadProc(void* lpvoid) {   
10.   
11.     print(a++);   
12.   
13.     A();       
14.   
15. }   
16.   
17.    
18.   
19. void A() {   
20.   
21.     print(a++);   
22.   
23.     B();   
24.   
25. }   
26.   
27.    
28.   
29. void B() {   
30.   
31.     print(a++);   
32.   
33.     C();   
34.   
35. }   
36.   
37.    
38.   
39. void C() {   
40.   
41.     print(a++);   
42.   
43. }  

  

 

       其调用链很清楚，ThreadProc->A->B->C然后再返回，调用链中的每个函数都引用了a并且修改了a的值，注意到，“全局变量”a是没有存储在线程堆栈中的，但是与此同时我们想让a成为线程所独有的数据，即，不期望发生同时多个ThreadProc线程的实例访问并修改同一个全局变量，导致运行结果不确定的情况，我们该怎么办？用TLS。如果不使用TLS，岂不是要大乱？

 

 

如下这张图生动的展示了TLS运行机制：

 

       该进程中有2个线程，Thread1和Thread2。它分配了2个Index给TLS使用，gdwTlsIndex1 和gdwTlsIndex2，每个线程分配了2个内存块分别存储数据，并且在TLS slots中存储了指针。要通过Index获得关联的数据，线程需要从TLS slot中通过指针指向的内存块实现，并存在 lpvData 这个本地变量中