一、线程退出
1、pthread_kill
（1）引用
#include <pthread.h>
#include<signal.h>
（2）函数原型
int pthread_kill(pthread_t thread, int sig);
（3）参数
- thread:线程ID
- sig:sig信号
（4）返回值
-
0:调用成功。
-
ESRCH：线程不存在。。
- EINVAL：信号不合法
（4）作用
向指定的线程传递sig信号。
（5）注意
别被名字吓到，pthread_kill可不是kill，而是向线程发送signal。还记得signal吗，大部分signal的默认动作是终止进程的运行，所以，我们才要用signal()去抓信号并加上处理函数。向指定ID的线程发送sig信号，如果线程代码内不做处理，则按照信号默认的行为影响整个进程，也就是说，如果你给一个线程发送了SIGQUIT，但线程却没有实现signal处理函数，则整个进程退出。如果要获得正确的行为，就需要在线程内实现signal(SIGKILL,sig_handler)了。
（6）程序实例
//使用pthread_kill函数检测一个线程是否还活着
/******************************* pthread_kill.c *******************************/
#include<stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
void *func1()/*1秒钟之后退出*/
{
sleep(1);
printf("线程1（ID：0x%x）退出。
",(unsigned int)pthread_self());
pthread_exit((void *)0);
}
void *func2()/*5秒钟之后退出*/
{
sleep(5);
printf("线程2（ID：0x%x）退出。
",(unsigned int)pthread_self());
pthread_exit((void *)0);
}
void test_pthread(pthread_t tid) /*pthread_kill的返回值：成功（0） 线程不存在（ESRCH） 信号不合法（EINVAL）*/
{
int pthread_kill_err;
pthread_kill_err = pthread_kill(tid,0);
if(pthread_kill_err == ESRCH)
printf("ID为0x%x的线程不存在或者已经退出。
",(unsigned int)tid);
else if(pthread_kill_err == EINVAL)
printf("发送信号非法。
");
else
printf("ID为0x%x的线程目前仍然存活。
",(unsigned int)tid);
}
int main()
{
int ret;
pthread_t tid1,tid2;
pthread_create(&tid1,NULL,func1,NULL);
pthread_create(&tid2,NULL,func2,NULL);
sleep(3);/*创建两个进程3秒钟之后，分别测试一下它们是否还活着*/
test_pthread(tid1);/*测试ID为tid1的线程是否存在*/
test_pthread(tid2);/*测试ID为tid2的线程是否存在*/
exit(0);
}
//kill给线程发信号
#include <pthread.h>
#include <stdio.h>
#include <sys/signal.h>
#define NUMTHREADS 3
void sighand(int signo);
void *threadfunc(void *parm)
{
pthread_t tid = pthread_self();
int rc;
printf("Thread %u entered/n", tid);
rc = sleep(30); /* 若有信号中断则返回剩余秒数 */
printf("Thread %u did not get expected results! rc=%d/n", tid, rc);
return NULL;
}
void *threadmasked(void *parm)
{
pthread_t tid = pthread_self();
sigset_t mask;
int rc;
printf("Masked thread %lu entered/n", tid);
sigfillset(&mask); /* 将所有信号加入mask信号集 */
/* 向当前的信号掩码中添加mask信号集 */
rc = pthread_sigmask(SIG_BLOCK, &mask, NULL);
if (rc != 0)
{
printf("%d, %s/n", rc, strerror(rc));
return NULL;
}
rc = sleep(15);
if (rc != 0)
{
printf("Masked thread %lu did not get expected results! rc=%d /n", tid, rc);
return NULL;
}
printf("Masked thread %lu completed masked work/n", tid);
return NULL;
}
int main(int argc, char **argv)
{
int rc;
int i;
struct sigaction actions;
pthread_t threads[NUMTHREADS];
pthread_t maskedthreads[NUMTHREADS];
printf("Enter Testcase - %s/n", argv[0]);
printf("Set up the alarm handler for the process/n");
memset(&actions, 0, sizeof(actions));
sigemptyset(&actions.sa_mask); /* 将参数set信号集初始化并清空 */
actions.sa_flags = 0;
actions.sa_handler = sighand;
/* 设置SIGALRM的处理函数 */
rc = sigaction(SIGALRM,&actions,NULL);
printf("Create masked and unmasked threads/n");
for(i=0; i<NUMTHREADS; ++i)
{
rc = pthread_create(&threads[i], NULL, threadfunc, NULL);
if (rc != 0)
{
printf("%d, %s/n", rc, strerror(rc));
return -1;
}
rc = pthread_create(&maskedthreads[i], NULL, threadmasked, NULL);
if (rc != 0)
{
printf("%d, %s/n", rc, strerror(rc));
return -1;
}
}
sleep(3);
printf("Send a signal to masked and unmasked threads/n");
/* 向线程发送SIGALRM信号 */
for(i=0; i<NUMTHREADS; ++i)
{
rc = pthread_kill(threads[i], SIGALRM);
rc = pthread_kill(maskedthreads[i], SIGALRM);
}
printf("Wait for masked and unmasked threads to complete/n");
for(i=0; i<NUMTHREADS; ++i) {
rc = pthread_join(threads[i], NULL);
rc = pthread_join(maskedthreads[i], NULL);
}
printf("Main completed/n");
return 0;
}
void sighand(int signo)
{
pthread_t tid = pthread_self();
printf("Thread %lu in signal handler/n", tid);
return;
}
2、pthread_exit
（1）函数原型
void pthread_exit(void* retval);
（2）参数
pthread_exit函数唯一的参数value_ptr是函数的返回代码，只要pthread_join中的第二个参数value_ptr不是NULL，这个值将被传递给value_ptr。
（3）作用
线程通过调用pthread_exit函数终止执行，就如同进程在结束时调用exit函数一样。这个函数的作用是，终止调用它的线程并返回一个指向某个对象的指针。
（4）用法
- 在线程中调用pthread_exit退出线程，在主线程中嗲用pthread_join函数阻塞等待结束并释放资源，pthread_exit的参数会传给pthread_join.
- 设置线程为分离属性，线程中调用pthread_exit退出线程后系统自动释放资源。
线程可以调用pthread_exit终止自己,有两种情况需要注意：
- 在主线程中，如果从main函数返回或是调用了exit函数退出主线程，则整个进程将终止，此时进程中有线程也将终止，因此在主线程中不能过早地从main函数返回；
- 如果主线程调用pthread_exit函数，则仅仅是主线程消亡，进程不会结束，进程内的其他线程也不会终止，直到所有线程结束，进程才会结束；
3、pthread_join
函数pthread_join用来等待一个线程的结束,线程间同步的操作。
pthread_join()函数，以阻塞的方式等待thread指定的线程结束。当函数返回时，被等待线程的资源被收回。如果线程已经结束，那么该函数会立即返回。并且thread指定的线程必须是joinable（合并）的。
（1）函数原型
int pthread_join( pthread_t thread, void * * value_ptr );
（2）参数
thread：线程ID
retval:用户定义的指针，用来存储被等待线程的返回值。
（3）返回值
0代表成功。 失败，返回的则是错误号。
（4）解释
- 代码中如果没有pthread_join主线程会很快结束从而使整个进程结束，从而使创建的线程没有机会开始执行就结束了。加入pthread_join后，主线程会一直等待直到等待的线程结束自己才结束，使创建的线程有机会执行。
- 通过pthread_join()函数来使主线程阻塞等待其他线程退出，这样主线程可以清理其他线程的环境。但是还有一些线程，更喜欢自己来清理退出的状态，他们也不愿意主线程调用pthread_join来等待他们。我们将这一类线程的属性称为detached（分离的）。如果我们在调用 pthread_create()函数的时候将属性设置为NULL，则表明我们希望所创建的线程采用默认的属性，也就是jionable（此时不是detached）。
4、pthread_cancel
（1）作用
用于取消一个函数，它通常需要被取消线程的配合。默认情况（延迟取消），它就是给pthread设置取消标志， pthread线程在很多时候会查看自己是否有取消请求。如果有就主动退出， 这些查看是否有取消的地方称为取消点。
当然，线程也不是被动的被别人结束。它可以通过设置自身的属性来决定如何结束。
线程的被动结束分为两种：
- 异步终结：当其他线程调用pthread_cancel的时候，线程就立刻被结束。
- 同步终结：同步终结则不会立刻终结，它会继续运行，直到到达下一个结束点（cancellation point）。当一个线程被按照默认的创建方式创建，那么它的属性是同步终结。
若是在整个程序退出时，要终止各个线程，应该在成功发送 CANCEL 指令后，使用 pthread_join 函数，等待指定的线程已经完全退出以后，再继续执行；否则，很容易产生 “段错误”。
（2）函数原型
#include<pthread.h>
int pthread_cancel(pthread_t thread)
（3）返回值
成功则返回0，否则为非0值。发送成功并不意味着thread会终止。
（4）用法
若是在整个程序退出时，要终止各个线程，应该在成功发送 CANCEL 指令后，使用 pthread_join 函数，等待指定的线程已经完全退出以后，再继续执行；否则，很容易产生 “段错误”。
int pthread_setcancelstate(int state, int *oldstate)
设置本线程对Cancel信号的反应，state有两种值：
- PTHREAD_CANCEL_ENABLE（缺省）：收到信号后设为CANCLED状态
- PTHREAD_CANCEL_DISABLE：忽略CANCEL信号继续运行；
old_state如果不为 NULL则存入原来的Cancel状态以便恢复。
int pthread_setcanceltype(int type, int *oldtype)
设置本线程取消动作的执行时机，
type由两种取值（仅当Cancel状态为Enable时有效）：
- PTHREAD_CANCEL_DEFERRED：表示收到信号后继续运行至下一个取消点再退出
- PTHREAD_CANCEL_ASYNCHRONOUS：立即执行取消动作（退出）
oldtype如果不为NULL则存入原来的取消动作类型值。
此函数应该在线程开始时执行，若线程内部有任何资源申请等操作，应该选择 PTHREAD_CANCEL_DEFERRED 的设定，然后在退出点（pthread_testcancel 用于定义退出点）进行线程退出。
void pthread_testcancel(void)
检查本线程是否处于Canceld状态，如果是，则进行取消动作，否则直接返回。 此函数在线程内执行，执行的位置就是线程退出的位置，在执行此函数以前，线程内部的相关资源申请一定要释放掉，他很容易造成内存泄露。
（5）程序实例
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> void* func(void *arg) { pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); //允许退出线程 pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); //设置立即取消 while(1)； return NULL; } int main(int argc,char *argv[]) { pthread_t thrd; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED); if(pthread_create(&thrd,&attr,func,NULL)) { perror( "pthread_create error "); exit(EXIT_FAILURE); } if(!pthread_cancel(thrd)) { printf("pthread_cancel OK "); } sleep(10); return 0;
}
5、exit()
如：exit(EXIT_SUCCESS)，是进程退出，如果在线程函数中调用exit，那改线程的进程也就挂了,会导致该线程所在进程的其他线程也挂掉，比较严重。
6、return
return是函数返回，不一定是线程函数，只有线程函数return，线程才会退出。
对比说明：
- pthread_join一般是主线程来调用，用来等待子线程退出，因为是等待，所以是阻塞的，一般主线程会依次join所有它创建的子线程。
- pthread_exit一般是子线程调用，用来结束当前线程。子线程可以通过pthread_exit传递一个返回值，而主线程通过pthread_join获得该返回值，从而判断该子线程的退出是正常还是异常。
二、资源清理
一旦又处于挂起状态的取消请求（即加锁之后，解锁之前），线程在执行到取消点时如果只是草草收场，这会将共享变量以及pthreads对象（例如互斥量）置于一种不一致状态，可能导致进程中其他线程产生错误结果、死锁，甚至造成程序崩溃。为避免这一问题：
使用清理函数pthread_cleanup_push()和pthread_cleanup_pop()来处理，这两个函数必需成对出现，不然会编译错误。
不论是可预见的线程种植还是异常终止，都会存在资源释放的问题，在不考虑因运行出错而退出的前提下，如何保证种植时能顺利的释放掉自己所占用的资源，包括单独申请的对内存，特别是锁资源，就是一个必需考虑的问题。
最近常出现的情形时资源独占锁的使用：
线程为了访问临界共享资源而为其加上锁，但在访问过程呗外界取消，或者发生了中断，则该临界资源将永远处于锁定状态得不到释放。外界取消操作是不可见的，因此的确需要一个机制来简化用于资源释放的编程。
在POSIX线程API中提供了一个pthread_clean_push()/pthread_cleanup_pop()函数对，用于自动释放资源----从pthread_cleanup_push()的调用点到pthread_cleanup_pop()之间的程序段中的终止动作都将执行pthread_cleanup_push()所指定的清理函数。
API定义如下：
void pthread_cleanup_push(void (*routine) (void *), void *arg)
void pthread_cleanup_pop(int execute)
pthread_cleanup_push()/pthread_cleanup_pop()采用先入后出的栈结构管理，
void routine(void *arg)函数在调用pthread_cleanup_push()时压入清理函数栈，多次对pthread_cleanup_push()的调用将在清理函数栈中形成一个函数链，在执行该函数链时按照压栈的相反顺序弹出。execute参数表示执行到pthread_cleanup_pop()时是否在弹出清理函数的同时执行该函数，为0表示不执行，非0为执行；这个参数并不影响异常终止时清理函数的执行。
有三种情况线程清理函数会被调用：
- 线程还未执行 pthread_cleanup_pop 前，被 pthread_cancel 取消
- 线程还未执行 pthread_cleanup_pop 前，主动执行 pthread_exit 终止
- 线程执行 pthread_cleanup_pop，且 pthread_cleanup_pop 的参数不为 0.
注意：如果线程还未执行 pthread_cleanup_pop 前通过 return 返回，是不会执行清理函数的。
void routine()函数可参照如下定义：
void *cleanup(void* p)
{
free(p);
printf("清理函数
");
}
线程主动清理过程的严谨写法：
void thread_fun(void*p)
{ p=malloc(20);
pthread_cleanup_push(cleanup,p);
printf("子线程
");
sleep(1); //系统调用，用来响应pthread_cancel函数
printf("是否杀死了线程
"); //如果线程在上一句被杀死，这一句不会被打印
pthread_exit(NULL); //不管线程是否被杀死，这一句都会检测清理函数，并执行
pthread_clean_pop(1);
}
注意：在子线程中如果申请了单独的堆空间，不应用free直接清理；因为假如在线程中直接free，如果，在free之后线程被取消，清理函数被执行，则会出现重复free的情况。
情况如下：
void thread_fun(void*p)
{
p=malloc(20);
pthread_cleanup_push(cleanup,p);
printf("子线程
");
sleep(1); //系统调用，用来响应pthread_cancel函数
printf("是否杀死了线程
"); //如果线程在上一句被杀死，这一句不会被打印
free(p); //不管线程是否被杀死，这一句都会检测清理函数，并执行<br>
//加入函数在此处被cancel ，可能会出现重复free
sleep(1);//在此处系统调用，响应pthread_cancel(),会执行清理函数.
return NULL;
pthread_clean_pop(1);//由于上一句return，所以这一句不执行，即清理函数不会执行
}
pthread_cleanup_push()/pthread_cleanup_pop()是以宏方式实现的，这是pthread.h中的宏定义：
#define pthread_cleanup_push(routine,arg)
{
struct _pthread_cleanup_buffer _buffer;
_pthread_cleanup_push (&_buffer, (routine), (arg));
#define pthread_cleanup_pop(execute)
_pthread_cleanup_pop (&_buffer, (execute));
}
可见,pthread_cleanup_push()带有一个"{"，而pthread_cleanup_pop()带有一个"}"，因此这两个函数必须成对出现，且必须位于程序的同一级别的代码段中才能通过编译。
在下面的例子里，当线程在"do some work"中终止时，将主动调用pthread_mutex_unlock(mut)，以完成解锁动作。
以下是使用方法：
pthread_cleanup_push(pthread_mutex_unlock, (void *) &mut);
pthread_mutex_lock(&mut);
.......
pthread_mutex_unlock(&mut);
pthread_cleanup_pop(0);
必须要注意的是，如果线程处于PTHREAD_CANCEL_ASYNCHRONOUS状态，上述代码段就有可能出错，因为CANCEL事件有可能在pthread_cleanup_push()和pthread_mutex_lock()之间发生，或者在pthread_mutex_unlock()和pthread_cleanup_pop()之间发生，
从而导致清理函数unlock一个并没有加锁的mutex变量，造成错误。因此，在使用清理函数的时候，都应该暂时设置成PTHREAD_CANCEL_DEFERRED模式。为此，POSIX的Linux实现中还提供了一对不保证可移植的pthread_cleanup_push_defer_np()/pthread_cleanup_pop_defer_np()
扩展函数，
功能与以下代码段相当：
{
int oldtype;
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);
pthread_cleanup_push(routine, arg);
......
pthread_cleanup_pop(execute);
pthread_setcanceltype(oldtype, NULL);
}
补充:
在线程宿主函数中主动调用return，如果return语句包含在pthread_cleanup_push()/pthread_cleanup_pop()对中，则不会引起清理函数的执行，反而会导致segment fault。