linux线程私有数据详解

    在单线程程序中,函数经常使用全局变量或静态变量,这是不会影响程序的正确性的,但如果线程调用的函数使用全局变量或静态变量,则很可能引起编程错误,因为这些函数使用的全局变量和静态变量无法为不同的线程保存各自的值,而当同一进程内的不同线程几乎同时调用这样的函数时就可能会有问题发生。而解决这一问题的一种方式就是使用线程私有数据。线程私有数据采用了一种被称为一键多值的技术，即一个键对应多个数值。访问数据时都是通过键值来访问，好像是对一个变量进行访问，其实是在访问不同的数据。使用线程私有数据时，首先要为每个线程数据创建一个相关联的键。在各个线程内部，都使用这个公用的键来指代线程数据，但是在不同的线程中，这个键代表的数据是不同的。

　根据<<unix环境高级编程>>中所涉及的设计线程私有数据的原因：

(1).在维护每个线程的私有数据的时候，我们可能会想到分配一个保存线程数据的数组，用线程的ID 作为数组的索引来实现访问，但是有一个问题是系统生成的线程ID不能保证是一个小而连续的整数， 并且用数组实现的时候由于其他线程也可以访问其数组中的数据，这样会 引起数据混乱。
(2).它提供了让基于进程的接口适应多线程环境的机制.一个很明显的实例就是errno。以前的接口(线程 出现以前)把errno定义为进程上下文中全局可访问的整数。系统调用和库例程在调用或执行失败时设置 errno,把它作为操作失败的附属结果。为了让线程也能够使用那些原本基于进程的系统调用和库例程，errno 被重定义为线程私有数据。这样，一个线程做了重置errno的操作也不会影响进程中其他线程的errno值。

线程私有数据的几个重要的含有：

[cpp]  view plain  copy

1. 1.int pthread_key_create (pthread_key_t *key, void (*destructor)(void *));  
2. //第一个参数为指向一个键值的指针，第二个参数指明了一个destructor函数，如果这个参数不为空，那么当每个线程结束时，系统将调用这个函数来释放绑定在这个  
3. //键上的内存块。  
4. 2.int pthread_key_delete (pthread_key_t key);  
5. 3.int pthread_setspecific (pthread_key_t key, const void *value);  
6. //其中value就是不同的线程中，key值所关联的私有数据地址，这些地址可以用malloc来分配;  
7. 4.void *pthread_getspecific (pthread_key_t key);  
8. //获取线程私有数据的地址  
9. 5.int phread_once(pthread_once_t *onceptr, vid(*init)(void));  
10. 注意：pthread_once 使用onceptr 参数指向的变量中的值确保init参数所指的函数在进程范围内之被调用一次，  
11. onceptr必须是一个非本地变量（即全局变量或者静态变量），而且必须初始化为PTHREAD_ONCE_INIT。  
12. pthread_key_t key;  
13. pthread_once_t once = PTHREAD_ONCE_INIT;  
14. void destructor(void *ptr){  
15.      free(ptr);  
16. }  
17. void excute_once(void)  {  
18.     pthread_key_create(&key, destructor);  
19.   
20. }  
21. int main(){  
22.    pthread_once(&r1_once, excute_once);  
23. }  

当我们调用pthread_key_create时，内核从Linux的TSD池中分配一项，将其值赋给key供以后访问使用，它的第一个参数key为指向键值的指针，第二个参数为一个函数指针，如果指针不为空，则在线程退出时将以key所关联的数据为参数调用destr_function()，释放分配的缓冲区。 key一旦被创建，所有线程都可以访问它，但各线程可以根据自己的需要往key中填入不同的值，这就相当于提供了一个同名而不同值的全局变量，一键多值。其中ＴＳＤ池的结构如下：

内核支持的pthread_keys是有限的(可能是128也可能)，除了进程范围内的Key结构数组之外，系统还在进程内维护了关于多个线程的多条信息。这些特定于线程的信息我们称之为Pthread结构。其中部分内容是我们称之为pkey数组的一个128个元素的指针数组。系统维护的关于每个线程的信息结构图如下：

一旦我们在某个线程里面调用pthread_setspecific将key与某个空间(这个空间可以是malloc申请的)相关连的时候，上面的结构就变成

下面我们用一个例子来解释线程的私有结构：

[cpp]  view plain  copy

1. #include <limits.h>    
2. #include <string.h>    
3. #include <pthread.h>    
4. #include <stdlib.h>    
5. #include <stdio.h>  
6. #include<iostream>  
7. using namespace std;  
8. pthread_key_t key;  
9. pthread_key_t key1;  
10. pthread_key_t key2;  
11. void func1(){  
12.     int *tmp = (int*)pthread_getspecific(key);  
13. }  
14.   
15. void *tthread_fun(void* args){  
16.     pthread_setspecific(key,args);  
17.     int *tmp = (int*)pthread_getspecific(key);  
18.     printf("线程%lu的私有地址为:%p\n",pthread_self(),tmp);  
19.     *tmp+=1;  
20.     func1();  
21.     return (void*)0;          
22. }  
23.   
24. int main(){  
25.     pthread_t pa, pb;  
26.     pthread_key_create(&key,NULL);  
27.     pthread_key_create(&key1,NULL);  
28.     pthread_key_create(&key2,NULL);  
29.     cout<<key<<" "<<key1<<" "<<key2<<endl;  
30.     pthread_t pid[3];  
31.     int a[3]={100,200,300};  
32.     cout<<"the address of array is: "<<&a<<endl;  
33.     int i=0;  
34.     for(i=0;i<3;i++){  
35.         pthread_create(&pid[i],NULL,tthread_fun,&a[i]);  
36.         cout<<"pthread id is: "<<pid[i]<<endl;  
37.   
38.     }  
39.     for(i=0;i<3;i++){  
40.         pthread_join(pid[i],NULL);  
41.   
42.     }  
43.     cout<<a[0]<<" "<<a[1]<<" "<<a[2]<<endl;  
44.     return 0;  
45. }  

输出结果：

从测试结果我们可以看出

（１）：key的值是从0(key)开始分配的，然后是1(key1)，再然后是2(key2)；

（２）：在进程里我们一共创建了3个进程，这三个进程共同使用一个键key（它额值为0），那么对应于每一个线程中的pkey[0]不同的线程的指向不同，就上面的程序而言，pid[0](可以看成线程Ａ)的pkey[0]里存放的是变量a[0]地址，pid[１](可以看成线程Ｂ)的pkey[0]里存放的是变量a[１]地址，pid[２](可以看成线程Ｃ)的pkey[0]里存放的是变量a[２]地址，这三个变量分别作为这三个线程的私有数据；函数fun1的关联结构为：

(3)：在不同的线程中：

[cpp]  view plain  copy

1. int *tmp = (int*)pthread_getspecific(key);  

虽然同样是key，但是我们得到的tem的地址对于每个线程来说不同，这些地址也就是图3中pkey[0]所指的地址;

另外还做了另一个实验：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <unistd.h>  
4. #include <sys/types.h>  
5. #include <pthread.h>  
6. #define THREAD_NUM 3  
7.   
8. void * thread_handler(void *arg){  
9.         printf("process id: %d\tthread id: %lu\n", getpid(),pthread_self());  
10. }  
11. int main(){  
12.         int i;  
13.         pthread_t tid[THREAD_NUM];  
14.     printf("process id: %d\tthread id: %lu\n", getpid(),pthread_self());  
15.         for(i = 0; i < THREAD_NUM; i++){  
16.                 pthread_create(&tid[i], NULL, thread_handler, NULL);  
17.         }  
18.         for(i = 0; i < THREAD_NUM; i++){  
19.                 pthread_join(tid[i],NULL);  
20.         }  
21.     return 0;  
22. }  

输出结果：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <unistd.h>  
4. #include <sys/types.h>  
5. #include <pthread.h>  
6. #define THREAD_NUM 3  
7. int main(){  
8.         int i;  
9.     printf("process id: %d\tthread id: %lu\n", getpid(),pthread_self());  
10.     return 0;  
11. }  

输出结果：

从上面两个例子可以看出，进程可以看成是主线程，占用一个线程号！！！！！

相关文章：

http://www.cnblogs.com/snake-hand/p/3148191.html 
http://blog.csdn.net/caigen1988/article/details/7901248 
http://www.2cto.com/kf/201312/261554.html 
http://blog.csdn.net/cywosp/article/details/26469435