1. 线程终止
线程的终止包括主动终止和被动终止两大类。
主动终止：
线程主函数执行return正常返回，返回值是线程的退出码。
线程主函数执行pthread_exit函数退出，其参数是一个传出参数，保存线程退出码。
被动终止：
在同一进程中其他线程调用pthread_cancel函数。
任意线程调用了exit、_Exit、_exit 导致整个进程终止，又或者主线程在main函数中执行return语句都会导致进程中的所有线程立即终止。
pthread_exit函数的作用是将单个线程退出。
void pthread_exit(void *retval);
参数retval：是一个void *类型的传出参数，保存着线程退出状态，如果不关心线程的退出状态可设置为NULL（传出参数）。
2. 线程终止实验
线程退出实验代码：
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
void *tfn(void *arg){
int i = (int)arg;
sleep(i);
//让第3个线程退出
if (i == 2) {
//exit(1); 使用exit函数会导致整个程序退出，禁止使用
//return NULL 会使当前函数结束并返回
pthread_exit(NULL); //将单个线程退出
}
printf("I'm %dth pthread tid = %lu\n", i+1, pthread_self());
return NULL;
}
int main(void) {
pthread_t tid;
int i, ret;
//创建了5个线程
for (i = 0; i < 5; i++) {
ret = pthread_create(&tid, NULL, tfn, (void *)i);
if (ret != 0) {
fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
exit(1);
}
}
printf("I'm main pthread tid = %lu\n", pthread_self());
//只让主线程退出
pthread_exit((void *)0);
//如果直接return的话，会将整个进程结束
//return 0;
}
程序执行结果：
从图中可以看到程序创建了5个线程，并让第3个线程调用pthread_exit提前终止了。如果主线程调用了pthread_exit函数，而非调用exit或执行return语句，那么其他线程将会正常执行，并不会退出。
另注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程主函数的栈上分配，因为当其它线程得到这个返回指针时，线程主函数已经退出了。
3. 回收线程资源
pthread_join会阻塞等待当前线程，直到指定的线程退出或执行pthread_exit函数，然后将线程回收，对应进程中 waitpid() 函数（pthread_join会阻塞，waitpid可以非阻塞）。
int pthread_join(pthread_t thread , void **retval);
参数说明：
thread：等待回收的线程id
retval：存储线程结束状态信息，如果不关心线程退出状态可设置为NULL
注意：如果线程通过return或exit结束时，在进程结束前，线程的资源并没有完全释放，这将会产生僵尸线程（类似于之前讲过的僵尸进程，可参考：19-孤儿进程与僵尸进程），所以需要通过pthread_join函数回收线程。
另外，调用一次pthread_join函数只回收一个线程，如果要回收多个线程需多次调用pthread_join函数。
回收线程实验：
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
//线程信息
typedef struct{
char name[30];
int age;
} student;
//线程主控函数
void *tfn(void *arg) {
student *s1 = NULL;
s1 = malloc(sizeof(student));
strcpy(s1->name , "zhangsan");
s1->age = 20;
pthread_exit((void *)s1);
return NULL;
}
int main(void){
pthread_t tid;
student *retval;
pthread_create(&tid, NULL, tfn, NULL);
//调用pthread_join可以获取线程退出时的状态信息
pthread_join(tid, (void **)&retval);
printf("name = %s, age = %d \n", retval->name, retval->age);
if(retval != NULL){
free(retval);
retval = NULL;
}
//printf(“a = %d , b = %d\n”, (student)retval->name , (student)retval->age);
return 0;
}
程序执行结果：
4. 线程分离
pthread_detach函数用于实现线程分离，分离的好处就是分离出来的线程执行结束，它将自动销毁，清理，不需要手动回收线程。
int pthread_detach(pthread_t thread);
参数thread：指定要分离的线程id
分离（detach）状态：线程主动与主控线程断开连接关系
线程一旦处于分离状态，则不能通过pthread_join函数来获取该线程的状态，因为线程分离后，其状态是不确定的。因此，如果不关心线程退出状态，希望线程退出时自动清理并销毁的话，使用pthread_detach是个不错的选择。
如果其他线程调用了exit或主线程执行return语句时，即便该线程已经处于分离状态，进程的所有线程都会退出。换句话说，pthread_detach函数只能控制线程终止之后所发生的事，而非何时终止线程。
线程分离实验：
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
//线程主控函数
void *tfn(void *arg) {
int n = 5;
while (n--) {
printf("pthread tfn n = %d\n", n);
sleep(1);
}
return (void *)7;
}
int main(void) {
pthread_t tid;
int ret = pthread_create(&tid, NULL, tfn, NULL);
//线程分离
pthread_detach(tid);
//一般来说线程已经处于分离态，就不能通过pthread_join来回收线程
int retvar = pthread_join(tid, (void **)&ret);
//pthread_join非0表示失败
if (retvar != 0) {
fprintf(stderr, "pthread_join error %s\n", strerror(retvar));
} else {
printf("pthread exit with %d\n", (int)ret);
}
sleep(6);
return 0;
}
程序执行结果：
当设置线程为分离状态后，调用pthread_join函数获取线程退出状态时出错了，这是因为处于detach状态的线程不会保留状态，所以再调用pthread_join函数获取状态就会返回EINVAL。
EINVAL错误的意思是pthread_join函数指定的线程处于分离状态。
一旦线程处于detach状态，就不能再调用pthread_join
5. 线程取消
一个线程可以调用pthread_cancel取消（终止）其他线程，pthread_cancel并不关心线程什么时候终止，它仅仅提出请求，pthread_cancel函数有点类似于进程中 kill() 函数（pthread_cancel只能取消同一个进程里的其他线程）。
int pthread_cancel(pthread_t thread);
参数：指定要取消的线程id
默认情况下，pthread_cancel函数指定的线程可以继续运行，直到线程到达某个取消点，如果设置了取消点，那么执行相应的动作，即杀死线程。
什么是取消点？
取消点是检查线程是否被取消，并按请求进行处理动作的一个位置（APUE的说法）。
简单来说，可以粗略的把取消点看做是一个系统调用，在POSIX.1多线程中，调用以下任何函数都会设置一个取消点：
6. 线程取消实验1
来看下面这个实验
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
//线程1主控函数
void *tfn1(void *arg) {
printf("thread 1 returning\n");
return (void *)111;
}
//线程2主控函数
void *tfn2(void *arg) {
printf("thread 2 exiting\n");
pthread_exit((void *)222);
}
//线程3主控函数
void *tfn3(void *arg) {
while (1) {
puts("thread 3 will going to die , 3 seconds after");
sleep(1); //根据图1所示，sleep调用本身就是一个取消点，默认处理动作就是杀死线程
}
}
int main(void) {
pthread_t tid;
void *tret = NULL;
//创建第一个线程
pthread_create(&tid, NULL, tfn1, NULL);
pthread_join(tid, &tret);
printf("thread 1 exit code = %d\n\n", (int)tret);
//创建第二个线程
pthread_create(&tid, NULL, tfn2, NULL);
pthread_join(tid, &tret);
printf("thread 2 exit code = %d\n\n", (int)tret);
//创建第三个线程
pthread_create(&tid, NULL, tfn3, NULL);
//为了查看前面2个线程的状态，睡眠3秒
sleep(3);
//把第三个线程设置为取消
pthread_cancel(tid);
pthread_join(tid, &tret);
printf("\nthread 3 is die , exit code = %d\n", (int)tret);
return 0;
}
程序执行结果：
线程3在等待了3秒后，最后退出时返回的状态是-1，说明线程3是异常退出的，被指定为取消线程。
这意味着如果线程没有到达取消点（没有调用系统调用），即便线程被设置为取消状态，也仍然不会终止，为了验证这一点，我们对线程3的线程主函数做以下修改：
//线程3主控函数
void *tfn3(void *arg) {
while (1) {
//puts("thread 3 will going to die , 3 seconds after");
//sleep(1);
//此时线程3没有取消点
}
}
程序执行结果：
线程3没有到达取消点后，即便线程3被设置为取消状态也不会结束，此时线程3正在while循环嗨皮的空转，而主线程还一直傻傻的阻塞等待线程3终止呢。
这说明了pthread_cancel函数仅仅提出取消的请求，简而言之，线程的取消并不是实时的，而是有一定的延时，需要等待线程到达某个取消点(检查点)才会执行处理动作（终止进程）。
7. pthread_testcancel函数
通过前面可知，即便线程被设置为取消，但没有到达取消点，线程依然不会终止，那有没有一种方法让被设置为取消的线程，但没有到达取消点的线程退出呢？答案是有的，pthread_testcancel函数就是用于检查线程是否处于cancel（取消点）状态，如果线程被设置为取消，那么将会执行处理动作杀死线程。
#include <pthread.h>
void pthread_testcancel(void)
还是对线程3的线程主函数做以下修改：
//线程3主控函数
void *tfn3(void *arg) {
while (1) {
//puts("thread 3 will going to die , 3 seconds after");
//sleep(1);
/*检查线程是否处于取消状态，如果是，则终止线程*/
pthread_testcancel();
}
}
程序执行结果：
调用pthread_cancel函数设置线程3为取消状态后，即便线程3没有到达取消点，依然能终止线程3，有同学可能会疑惑，为啥线程3退出的状态是-1？
其实被取消的线程的退出值定义在Linux的pthread库中，常数PTHREAD_CANCELED的值是-1，可以在头文件pthread.h中找到它的定义：#define PTHREAD_CANCELED ((void *) -1)
pthread_cancel函数是一个很诡异的函数，坑多，不推荐大家使用。
8. 总结
- 掌握线程终止，线程回收，线程分离
- 了解线程取消，理解取消点的概念
- 小心使用pthread_cancel函数