pthread_exit与pthread_join的区别

pthread_exit(void *ptr) 函数使线程退出，并返回一个空指针类型的值。

pthread_join(pthread_t tid,void **rtval)调用此函数的进程/线程等id为tid的线程返回或被终止，并从它那里获得返回值。

注意，退出函数返回的是一个空指针类型，接受函数也必须用一个指针来接收。但是函数给出的参数是接收指针的地址，即，接收到的指针值写入给出的地址处的指针变量。

另外还有一个有趣的现象：

[plain] view plain copy

print?

1. #include<stdio.h>  
2. #include<unistd.h>  
3. #include<stdlib.h>  
4. #include<string.h>  
5. #include<pthread.h>  
6. void *func(void *arg);  
7. int main()  
8. {  
9.   int res;  
10.   pthread_t a_thread;  
11.   void *thread_res;  
12.   res = pthread_create(&a_thread,NULL,func,(void*)0);  
13.   if(res != 0)  
14.   {  
15.     perror("Fail to create a new thread");  
16.     exit(EXIT_FAILURE);  
17.   }  
18.   printf("Waiting  for the thread to finish...thread_res -->%0x\n",thread_res);  
19.   res = pthread_join(a_thread,(void*)&thread_res);  
20.   if(res != 0)  
21.   {  
22.     perror("thread join error");  
23.     exit(EXIT_FAILURE);  
24.   }  
25.   printf("pointer return from thread is thread_res = %0x\n",thread_res);  
26.   printf("thread finished! return value:%s\n",(char *)thread_res);  
27.   exit(EXIT_SUCCESS);  
28. }  
29. void *func(void *arg)  
30. {  
31.   sleep(3);  
32.   pthread_exit("Thread funtion finished!\n");  
33. }  

#include<stdio.h>#include<unistd.h>#include<stdlib.h>#include<string.h>#include<pthread.h>void *func(void *arg);int main(){  int res;  pthread_t a_thread;  void *thread_res;  res = pthread_create(&a_thread,NULL,func,(void*)0);  if(res != 0)  {    perror("Fail to create a new thread");    exit(EXIT_FAILURE);  }  printf("Waiting  for the thread to finish...thread_res -->%0x\n",thread_res);  res = pthread_join(a_thread,(void*)&thread_res);  if(res != 0)  {    perror("thread join error");    exit(EXIT_FAILURE);  }  printf("pointer return from thread is thread_res = %0x\n",thread_res);  printf("thread finished! return value:%s\n",(char *)thread_res);  exit(EXIT_SUCCESS);}void *func(void *arg){  sleep(3);  pthread_exit("Thread funtion finished!\n");}

如果想用这两个函数传递一个double型的数据的话，在线程函数中定义一个double型数据，在pthread_exit中使用(void*)double，但是这个转化是无效的，因为double是8字节，而指针类型4字节，所以无法传递。使用这种办法传递整型数据还是可以的。

上面的程序中，pthread_exit的参数是一个字符串，但是传递回去的是该字符串的指针。接收方的空指针类型数据thread_res开始并未初始化，可以看到值为8048660，指向不确定的地方。当接收到字符串地址后，该数据有了一个值80487ee，而且这个地址是有效的地址，可以定位到字符串。但是如果在线程函数内定义一个字符串，然后把字符串的首地址传递给接收进程的话，可以收到地址，但这是地址已经无效，无法用此地址输出一个之前定义的字符串。

猜想：难道是线程解释之后，之前申请的地址都释放了，所以之前的地址内的字符串也没了。。但是，直接给出的字符串有什么区别呢？这样不通过标识符引用而直接给出的字符串到底存储在内存中的什么 地方？静态存储区？

答：在函数中定义的变量对应分配的存储单元是在栈区创建，函数执行结束这些内存即被释放。因此原先函数中义的数据就丢失了。而函数中的常量字符串是在编译的时候就分配了内存，存储在静态存储区，函数的整个运行期间都有效。因此还可以根据传回的地址定位到该字符串。

****************************************************************************************************************

继续猜想：那么，如果在函数中用malloc分配一段内存，并把该段内存首地址传回，应该也可以定位到这里的数据。malloc的内存是在堆区。

[plain] view plain copy

print?

1. #include<stdio.h>  
2. #include<unistd.h>  
3. #include<stdlib.h>  
4. #include<string.h>  
5. #include<pthread.h>  
6. void *func(void *arg);  
7. int main()  
8. {  
9.   int res;  
10.   pthread_t a_thread;  
11.   void* thread_res;  
12.   char ss[] = "in main";  
13.   res = pthread_create(&a_thread,NULL,func,(void*)ss);  
14.   if(res != 0)  
15.   {  
16.     perror("Fail to create a new thread");  
17.     exit(EXIT_FAILURE);  
18.   }  
19.   printf("Waiting  for the thread to finish...\n");  
20.   res = pthread_join(a_thread,&thread_res);  
21.   if(res != 0)  
22.   {  
23.     perror("thread join error");  
24.     exit(EXIT_FAILURE);  
25.   }  
26.   printf("thread finished! return value:%0x --- %s\n",thread_res,(char*)thread_res);  
27.   free(thread_res);  
28.   exit(EXIT_SUCCESS);  
29. }  
30. void *func(void *arg)  
31. {  
32.   char *s = (char*)malloc(10);  
33.   char ss[] = "message from new thread~~~~~\n";  
34.   char *sss = "shit on you!";  
35.   strcpy(s,"hallow");  
36.   printf("s[0] -- %c  s[1] %c\n",s[0],s[1]);  
37.   printf("ss[0] -- %c  ss[1] -- %c\n",ss[0],ss[1]);  
38.   printf("sss[0] -- %c  sss[1] -- %c\n",sss[0],sss[1]);  
39.   s[0] = 'c';  
40.   sss[0] = 'c';  
41.   printf("thread function is running,Argument is %s\n",(char *)arg);  
42.   sleep(3);  
43.   pthread_exit((void*)s);  
44. }  

#include<stdio.h>#include<unistd.h>#include<stdlib.h>#include<string.h>#include<pthread.h>void *func(void *arg);int main(){  int res;  pthread_t a_thread;  void* thread_res;  char ss[] = "in main";  res = pthread_create(&a_thread,NULL,func,(void*)ss);  if(res != 0)  {    perror("Fail to create a new thread");    exit(EXIT_FAILURE);  }  printf("Waiting  for the thread to finish...\n");  res = pthread_join(a_thread,&thread_res);  if(res != 0)  {    perror("thread join error");    exit(EXIT_FAILURE);  }  printf("thread finished! return value:%0x --- %s\n",thread_res,(char*)thread_res);  free(thread_res);  exit(EXIT_SUCCESS);}void *func(void *arg){  char *s = (char*)malloc(10);  char ss[] = "message from new thread~~~~~\n";  char *sss = "shit on you!";  strcpy(s,"hallow");  printf("s[0] -- %c  s[1] %c\n",s[0],s[1]);  printf("ss[0] -- %c  ss[1] -- %c\n",ss[0],ss[1]);  printf("sss[0] -- %c  sss[1] -- %c\n",sss[0],sss[1]);  s[0] = 'c';  sss[0] = 'c';  printf("thread function is running,Argument is %s\n",(char *)arg);  sleep(3);  pthread_exit((void*)s);}

上面代码中，在线程函数中分别在堆区，栈区，静态存储区定义了内存空间。在堆区用malloc分配的存储空间是可以保留下来的。但是在主程序中不要忘记释放掉之前申请的空间，否则会造成内存泄漏。
对于堆，栈和静态存储区，都可以用s[0] s[1]定位其中的字符。
但是不能对静态存储区的内容进行修改，否则运行出现错误（编译可通过）。
××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
附录：C++ 静态存储区 栈 堆的区别             很多人都觉得学习C++是特别困难的事情。C＋＋学习是比较复杂的：它的内存分配、指针、以及面向对象思想的实现等等，确实需要一定的技术积累。我们将以专题的形式，为大家逐一剖析c＋＋的技术重点和难点。本专题讨论的就是内存分配。学习c＋＋如果不了解内存分配是一件非常可悲的事情。而且，可以这样讲，一个C＋＋程序员无法掌握内存、无法了解内存，是不能够成为一个合格的C＋＋程序员的。一、内存基本构成可编程内存在基本上分为这样的几大部分：静态存储区、堆区和栈区。他们的功能不同，对他们使用方式也就不同。静态存储区：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。它主要存放静态数据、全局数据和常量。栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。堆区：亦称动态内存分配。程序在运行的时候用malloc或new申请任意大小的内存，程序员自己负责在适当的时候用free或delete释放内存。动态内存的生存期可以由我们决定，如果我们不释放内存，程序将在最后才释放掉动态内存。 但是，良好的编程习惯是：如果某动态内存不再使用，需要将其释放掉，否则，我们认为发生了内存泄漏现象。二、三者之间的区别我们通过代码段来看看对这样的三部分内存需要怎样的操作和不同，以及应该注意怎样的地方。例一：静态存储区与栈区char* p = “Hello World1”;char a[] = “Hello World2”;p[2] = ‘A’;a[2] = ‘A’;char* p1 = “Hello World1;”这个程序是有错误的，错误发生在p[2] = ‘A’这行代码处，为什么呢，是变量p和变量数组a都存在于栈区的（任何临时变量都是处于栈区的，包括在main（）函数中定义的变量）。但是，数据“Hello World1”和数据“Hello World2”是存储于不同的区域的。因为数据“Hello World2”存在于数组中，所以，此数据存储于栈区，对它修改是没有任何问题的。因为指针变量p仅仅能够存储某个存储空间的地址，数据“Hello World1”为字符串常量，所以存储在静态存储区。虽然通过p[2]可以访问到静态存储区中的第三个数据单元，即字符‘l’所在的存储的单元。但是因为数据“Hello World1”为字符串常量，不可以改变，所以在程序运行时，会报告内存错误。并且，如果此时对p和p1输出的时候会发现p和p1里面保存的地址是完全相同的。换句话说，在数据区只保留一份相同的数据（见图1－1）。例二：栈区与堆区char* f1(){char* p = NULL;char a;p = &a;return p;}char* f2(){char* p = NULL:p =(char*) new char[4];return p;}这两个函数都是将某个存储空间的地址返回，二者有何区别呢？f1()函数虽然返回的是一个存储空间，但是此空间为临时空间。也就是说，此空间只有短暂的生命周期，它的生命周期在函数f1()调用结束时，也就失去了它的生命价值，即：此空间被释放掉。所以，当调用f1()函数时，如果程序中有下面的语句：char* p ;p = f1();*p = ‘a’;此时，编译并不会报告错误，但是在程序运行时，会发生异常错误。因为，你对不应该操作的内存（即，已经释放掉的存储空间）进行了操作。但是，相比之下，f2()函数不会有任何问题。因为，new这个命令是在堆中申请存储空间，一旦申请成功，除非你将其delete或者程序终结，这块内存将一直存在。也可以这样理解，堆内存是共享单元，能够被多个函数共同访问。如果你需要有多个数据返回却苦无办法，堆内存将是一个很好的选择。但是一定要避免下面的事情发生：void f(){…char * p;p = (char*)new char[100];…}这个程序做了一件很无意义并且会带来很大危害的事情。因为，虽然申请了堆内存，p保存了堆内存的首地址。但是，此变量是临时变量，当函数调用结束时p变量消失。也就是说，再也没有变量存储这块堆内存的首地址，我们将永远无法再使用那块堆内存了。但是，这块堆内存却一直标识被你所使用（因为没有到程序结束，你也没有将其delete，所以这块堆内存一直被标识拥有者是当前您的程序），进而其他进程或程序无法使用。我们将这种不道德的“流氓行为”（我们不用，却也不让别人使用）称为内存泄漏。这是我们C++程序员的大忌！！请大家一定要避免这件事情的发生。总之，对于堆区、栈区和静态存储区它们之间最大的不同在于，栈的生命周期很短暂。但是堆区和静态存储区的生命周期相当于与程序的生命同时存在（如果您不在程序运行中间将堆内存delete的话），我们将这种变量或数据成为全局变量或数据。但是，对于堆区的内存空间使用更加灵活，因为它允许你在不需要它的时候，随时将它释放掉，而静态存储区将一直存在于程序的整个生命周期中。我们此专题仅仅是简要的分析了内存基本构成以及使用它们时需要注意的问题。对内存的分析和讨论将一直贯穿于我们以后所有的专题，这也就是为什么把它作为第一讲的原因。××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

[plain] view plain copy

print?

1. <pre></pre>  
2. <pre></pre>  
3. <pre></pre>  
4. <pre></pre>  
5. <pre></pre>  
6.