Linux多线程实践(4) --线程特定数据

线程特定数据

[cpp] view plain copy

1. int pthread_key_create(pthread_key_t *key, void (*destr_function) (void *));  
2. int pthread_key_delete(pthread_key_t key);  
3.   
4. int pthread_setspecific(pthread_key_t key, const void *pointer);  
5. void * pthread_getspecific(pthread_key_t key);  
6.   
7. pthread_once_t once_control = PTHREAD_ONCE_INIT;  
8. int pthread_once(pthread_once_t *once_control, void (*init_routine) (void));  

   在单线程程序中，我们经常要用到"全局变量"以实现多个函数间共享数据, 然而在多线程环境下，由于数据空间是共享的，因此全局变量也为所有线程所共有。但有时应用程序设计中有必要提供线程私有的全局变量，仅在某个线程中有效，但却可以跨多个函数访问。POSIX线程库通过维护一定的数据结构来解决这个问题，这个些数据称为（Thread-specific-data或 TSD）, 线程特定数据如下图所示:

 

 

   从上图可知:当调用pthread_key_create 后会产生一个所有线程都可见的线程特定数据（TSD）的键值(如上图中所有的线程都会得到一个pkey[1]的值), 但是这个键所指向的真实数据却是不同的,虽然都是pkey[1], 但是他们并不是指向同一块内存,而是指向了只属于自己的实际数据, 因此, 如果线程0更改了pkey[1]所指向的数据, 而并不能够影像到线程n;

   在线程调用pthread_setspecific后会将每个线程的特定数据与thread_key_t绑定起来，虽然只有一个pthread_key_t，但每个线程的特定数据是独立的内存空间，当线程退出时会执行destructor 函数。

[cpp] view plain copy

1. /** 示例1: 设置/获取线程特定数据 
2. 在两个线程中分别设置/获取线程特定数据, 查看两个线程中的数据是否是一样的(肯定是不一样的O(∩_∩)O~) 
3. **/  
4. pthread_key_t key;  
5. typedef struct Tsd  
6. {  
7.     pthread_t tid;  
8.     char *str;  
9. } tsd_t;  
10. //用来销毁每个线程所指向的实际数据  
11. void destructor_function(void *value)  
12. {  
13.     free(value);  
14.     cout << "destructor ..." << endl;  
15. }  
16.   
17. void *thread_routine(void *args)  
18. {  
19.     //设置线程特定数据  
20.     tsd_t *value = (tsd_t *)malloc(sizeof(tsd_t));  
21.     value->tid = pthread_self();  
22.     value->str = (char *)args;  
23.     pthread_setspecific(key, value);  
24.     printf("%s setspecific, address: %p\n", (char *)args, value);  
25.   
26.     //获取线程特定数据  
27.     value = (tsd_t *)pthread_getspecific(key);  
28.     printf("tid: 0x%x, str = %s\n", (unsigned int)value->tid, value->str);  
29.     sleep(2);  
30.   
31.     //再次获取线程特定数据  
32.     value = (tsd_t *)pthread_getspecific(key);  
33.     printf("tid: 0x%x, str = %s\n", (unsigned int)value->tid, value->str);  
34.   
35.     pthread_exit(NULL);  
36. }  
37.   
38. int main()  
39. {  
40.     //这样每个线程当中都会有一个key可用了,  
41.     //但是每个key所绑定的实际区域需要每个线程自己指定  
42.     pthread_key_create(&key, destructor_function);  
43.   
44.     pthread_t tid1, tid2;  
45.     pthread_create(&tid1, NULL, thread_routine, (void *)"thread1");  
46.     pthread_create(&tid2, NULL, thread_routine, (void *)"thread2");  
47.   
48.     pthread_join(tid1, NULL);  
49.     pthread_join(tid2, NULL);  
50.     pthread_key_delete(key);  
51.   
52.     return 0;  
53. }  

[cpp] view plain copy

1. /** 示例2:运用pthread_once, 让key只初始化一次 
2. 注意: 将对key的初始化放入到init_routine中 
3. **/  
4. pthread_key_t key;  
5. pthread_once_t once_control = PTHREAD_ONCE_INIT;  
6. typedef struct Tsd  
7. {  
8.     pthread_t tid;  
9.     char *str;  
10. } tsd_t;  
11.   
12. //线程特定数据销毁函数,  
13. //用来销毁每个线程所指向的实际数据  
14. void destructor_function(void *value)  
15. {  
16.     free(value);  
17.     cout << "destructor ..." << endl;  
18. }  
19.   
20. //初始化函数, 将对key的初始化放入该函数中,  
21. //可以保证inti_routine函数只运行一次  
22. void init_routine()  
23. {  
24.     pthread_key_create(&key, destructor_function);  
25.     cout << "init..." << endl;  
26. }  
27.   
28. void *thread_routine(void *args)  
29. {  
30.     pthread_once(&once_control, init_routine);  
31.   
32.     //设置线程特定数据  
33.     tsd_t *value = (tsd_t *)malloc(sizeof(tsd_t));  
34.     value->tid = pthread_self();  
35.     value->str = (char *)args;  
36.     pthread_setspecific(key, value);  
37.     printf("%s setspecific, address: %p\n", (char *)args, value);  
38.   
39.     //获取线程特定数据  
40.     value = (tsd_t *)pthread_getspecific(key);  
41.     printf("tid: 0x%x, str = %s\n", (unsigned int)value->tid, value->str);  
42.     sleep(2);  
43.   
44.     //再次获取线程特定数据  
45.     value = (tsd_t *)pthread_getspecific(key);  
46.     printf("tid: 0x%x, str = %s\n", (unsigned int)value->tid, value->str);  
47.   
48.     pthread_exit(NULL);  
49. }  
50.   
51. int main()  
52. {  
53.     pthread_t tid1, tid2;  
54.     pthread_create(&tid1, NULL, thread_routine, (void *)"thread1");  
55.     pthread_create(&tid2, NULL, thread_routine, (void *)"thread2");  
56.   
57.     pthread_join(tid1, NULL);  
58.     pthread_join(tid2, NULL);  
59.     pthread_key_delete(key);  
60.   
61.     return 0;  
62. }  

附-Linux/Unix线程私有数据实现思想:

原文连接:http://blog.csdn.net/caigen1988/article/details/7901248

   线程私有数据实现的主要思想是：在分配线程私有数据之前，创建与该数据相关联的键，这个键可以被进程中的所有线程使用，但每个线程把这个键与不同的线程私有数据地址进行关联，需要说明的是每个系统支持有限数量的线程特定数据元素（如:限制为128个）。那么这个键的实现原理是什么呢？

    其实系统为每个进程维护了一个称之为 Key 结构的结构数组，如下图所示：

（图1）

   在上图中Key 结构的“标志”指示这个数据元素是否正在使用。在刚开始时所有的标志初始化为“不在使用”。当一个线程调用pthread_key_create创建一个新的线程特定数据元素时，系统会搜索Key结构数组，找出第一个“不在使用”的元素。并把该元素的索引(0~127,称为“键”)返回给调用线程。

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

 

（图2）

   在上图中，pkey数组所有元素都被初始化为空指针。这些128个指针是和进程内128个可能的键逐一关联的值。

那么当我们调用pthread_key_create函数时，系统会为我们做什么呢？

    系统首先会返回给我们一个Key结构数组中第一个“未被使用”的键（即索引值），每个线程可以随后通过该键找到对应的位置，并且为这个位置存储一个值（指针）。 一般来说，这个指针通常是每个线程通过调用malloc来获得的。

知道了大概的私有数据实现的原理，那么在编程中如何使用线程的特定数据呢？

   假设一个进程被启动，并且多个线程被创建。 其中一个线程调用pthread_key_create。系统在Key结构数组（图1）中找到第1个未使用的元素。并把它的索引（0~127）返回给调用者。我们假设找到的索引为1。

之后线程调用pthread_getspecific获取本线程的pkey[1] 的值（图（2）中键1所值的指针）， 返回值是一个空值，线程那么调用malloc分配内存区并初始化此内存区。 之后线程调用pthread_setspecific把对应的所创建键的线程特定数据指针(pkey[1]) 设置为指向它刚刚分配的内存区。下图指出了此时的情形。

 

（图3）

明白了怎样获取线程的特定数据值，那么如果线程终止时系统会执行什么操作呢？

   我们知道，一个线程调用pthread_key_create创建某个特定的数据元素时，所指定的参数之一便是指向析构函数的指针。当一个线程终止时，系统将扫描该线程的pkey数组，为每个非空的pkey指针调用相应的析构函数。 相应的析构函数是存放在图1中的Key数组中的函数指针。这是一个线程终止时其线程特定数据的释放手段。