下面说一下线程中特有的线程存储， Thread Specific Data 。线程存储有什么用了？他是什么意思了？大家都知道，在多线程程序中，所有线程共享程序中的变量。现在有一全局变量，所有线程都可以使用它，改变它的值。而如果每个线程希望能单独拥有它，那么就需要使用线程存储了。表面上看起来这是一个全局变量，所有线程都可以使用它，而它的值在每一个线程中又是单独存储的。这就是线程存储的意义。下面说一下线程存储的具体用法。l          创建一个类型为 pthread_key_t 类型的变量。l          调用 pthread_key_create() 来创建该变量。该函数有两个参数，第一个参数就是上面声明的 pthread_key_t 变量，第二个参数是一个清理函数，用来在线程释放该线程存储的时候被调用。该函数指针可以设成 NULL ，这样系统将调用默认的清理函数。l          当线程中需要存储特殊值的时候，可以调用 pthread_setspcific() 。该函数有两个参数，第一个为前面声明的 pthread_key_t 变量，第二个为 void* 变量，这样你可以存储任何类型的值。l          如果需要取出所存储的值，调用 pthread_getspecific() 。该函数的参数为前面提到的 pthread_key_t 变量，该函数返回 void * 类型的值。下面是前面提到的函数的原型：int pthread_setspecific(pthread_key_t key, const void *value);void *pthread_getspecific(pthread_key_t key);int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));下面是一个如何使用线程存储的例子：

最后说一下线程的本质。其实在Linux 中，新建的线程并不是在原先的进程中，而是系统通过一个系统调用clone() 。该系统copy 了一个和原先进程完全一样的进程，并在这个进程中执行线程函数。不过这个copy 过程和fork 不一样。copy 后的进程和原先的进程共享了所有的变量，运行环境。这样，原先进程中的变量变动在copy 后的进程中便能体现出来

//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------/先记下来，以后有机会请教高手

最近学习通过pthread_key_create创建的线程专有数据时发现如果不对线程使用pthread_join，则不会调用pthread_key_create所指定的资源释放函数。而并没有像书上所说的在线程pthread_exit()后就会调用释放函数。这是为什么？究竟什么情况下会调用？
我使用的测试程序：

这是程序输出 
---------------------------------------------- 
hello 
thread 1083395264 enter 
thread 1091783744 enter 
thread 1091783744 returns 1091783744 
thread 1083395264 returns 1083395264 
destructor excuted in thread 1075005312, param=1091783744
main thread 1075005312 exit

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

1. #include    <pthread.h>
2. #include    <stdio.h>
3. #include    <unistd.h>
4. #include    <stdlib.h> //atexit
5. using  namespace  std;
6. pthread_key_t  key;
7. pthread_once_t thread_once = PTHREAD_ONCE_INIT;
8. void echomsg(void *);
9. void once_run(void)
10. {
11. printf("pthread_key_t init in the once_run\n  ");
12. pthread_key_create(&key,echomsg);
13. }
14. void  echomsg(void*  p)
15. {
16. int  t=*(int*)p;
17. printf(  "destructor  excuted  in  thread  %d,  param=%d\n  ",pthread_self(),t);
18. delete (int *)p;
19. }
20. void*  child1(void*  arg)
21. {
22. int*ptid=  new  int;
23. pthread_once(&thread_once, once_run);//测试pthread_once是否还会在此执行不，因为在main线程已经执行了.
24. *ptid=pthread_self();
25. printf(  "thread1  %d  enter\n  ",*ptid);
26. pthread_setspecific(key,(void*)ptid);
27. sleep(2);
28. printf(  "thread1  %d  returns  %d\n  ",*ptid,*((int*)pthread_getspecific(key)));
29. sleep(5);
30. pthread_exit(NULL);
31. return  NULL;
32. }
33. void*  child2(void*  arg)
34. {
35. int*ptid=  new  int;
36. *ptid=pthread_self();
37. printf(  "thread2  %d  enter\n  ",*ptid);
38. pthread_setspecific(key,(void*)ptid);
39. sleep(1);
40. printf(  "thread2  %d  returns  %d\n  ",*ptid,*((int*)pthread_getspecific(key)));
41. sleep(1);
42. pthread_exit(NULL);
43. return  NULL;
44. }
45. void main_exit()
46. {
47. pthread_key_delete(key);
48. }
49. int  main()
50. {
51. pthread_t  tid1,tid2;
52. printf(  "hello\n  ");
53. atexit(main_exit);//为了防止sleep(4)放到pthread_key_delete(key)后面就会出现段错误了。但是个人也不很提倡用atexit这个函数。
54. pthread_once(&thread_once, once_run);
55. //pthread_key_create(&key,echomsg);  //保证一次性运行把其放到了pthread_once了
56. pthread_create(&tid1,NULL,child1,NULL);
57. pthread_create(&tid2,NULL,child2,NULL);
58. //pthread_join(tid1,NULL);
59. //pthread_join(tid2,NULL);
60. sleep(3);
61. //pthread_key_delete(key);
62. printf(  "main  thread  %d  exit\n  ",pthread_self());
63. return  0;
64. }

转自：http://blog.csdn.net/yuyin86/article/details/6735245

一次性初始化

有时候我们需要对一些posix变量只进行一次初始化，如线程键（我下面会讲到）。如果我们进行多次初始化程序就会出现错误。

在传统的顺序编程中，一次性初始化经常通过使用布尔变量来管理。控制变量被静态初始化为0，而任何依赖于初始化的代码都能测试该变量。如果变量值仍然为0，则它能实行初始化，然后将变量置为1。以后检查的代码将跳过初始化。

但是在多线程程序设计中，事情就变的复杂的多。如果多个线程并发地执行初始化序列代码，可能有2个线程发现控制变量为0，并且都实行初始化，而该过程本该仅仅执行一次。

如果我们需要对一个posix变量静态的初始化，可使用的方法是用一个互斥量对该变量的初始话进行控制。但有时候我们需要对该变量进行动态初始化，pthread_once就会方便的多。

函数原形：

pthread_once_t once_control=PTHREAD_ONCE_INIT;

int pthread_once(pthread_once_t *once_control,void(*init_routine)(void));

参数：

once_control         控制变量

init_routine         初始化函数

返回值：

若成功返回0，若失败返回错误编号。

类型为pthread_once_t的变量是一个控制变量。控制变量必须使用PTHREAD_ONCE_INIT宏静态地初始化。

pthread_once函数首先检查控制变量，判断是否已经完成初始化，如果完成就简单地返回；否则，pthread_once调用初始化函数，并且记录下初始化被完成。如果在一个线程初始时，另外的线程调用pthread_once，则调用线程等待，直到那个现成完成初始话返回。

下面就是该函数的程序例子：

#include <pthread.h>

pthread_once_t once=PTHREAD_ONCE_INIT;

pthread_mutex_t mutex;　

void once_init_routine(void)　

{

int status;

status=pthread_mutex_init(&mutex,NULL);

if(status==0)

printf(“Init success!,My id is %u”,pthread_self());

}

void *child_thread(void *arg)

{

printf(“I’m child ,My id is %u”,pthread_self());

pthread_once(&once,once_init_routine);

}

int main(int argc,char *argv[ ])

{

pthread_t child_thread_id;

pthread_create(&child_thread_id,NULL,child_thread,NULL);

printf(“I’m father,my id is %u”,pthread_self());

pthread_once(&once_block,once_init_routine);

pthread_join(child_thread_id,NULL);

}

线程的私有数据

在进程内的所有线程共享相同的地址空间，任何声明为静态或外部的变量，或在进程堆声明的变量，都可以被进程所有的线程读写。那怎样才能使线程序拥有自己的私有数据呢。

posix提供了一种方法，创建线程键。

函数原形：

int pthread_key_create(pthread_key *key,void(*destructor)(void *));

参数：

key           私有数据键

destructor    清理函数

返回值：

若成功返回0，若失败返回错误编号

第一个参数为指向一个键值的指针，第二个参数指明了一个destructor函数（清理函数），如果这个参数不为空，那么当每个线程结束时，系统将调用这个函数来释放绑定在这个键上的内存块。这个函数常和函数pthread_once一起使用，为了让这个键只被创建一次。函数pthread_once声明一个初始化函数，第一次调用pthread_once时它执行这个函数，以后的调用将被它忽略。

下面是程序例子：

#include <pthread.h>

pthread_key_t tsd_key;

pthread_once_t key_once=PTHREAD_ONCE_INIT;

void once_routine(void)

{

int status;

status=pthread_key_create(&tsd_key,NULL);

if(status=0)

printf(“Key create success! My id is %u/n”,pthread_self());

}

void *child_thread(void *arg)

{

printf(“I’m child,My id is %u/n”,pthread_self());

pthread_once(&key_once,once_routine);

}

int main(int argc,char *argv[ ])

{

pthread_t child_thread_id;

pthread_create(&child_thread_id,NULL,child_thread,NULL);

printf(“I’m father,my id is%u/n”,pthread_self());

pthread_once(&key_once,once_routine);

}