Unix/Linux编程：线程取消

朴灿烈づ我的快乐病毒、 2022-10-17 00:41 172阅读 0赞

# 线程取消 #

在通常情况下，程序中的多个线程会并发执行，每个线程各司其职，直至其决意退出，随即会调用函数 pthread\_exit()或者从线程启动函数中返回

有时候，需要将一个线程取消（cancel）。亦即，向线程发送一个请求，要求其立即退出。比如，一组线程正在执行一个运算，一旦某个线程检测到错误发生，需要其他线程退出，取消线程的功能这时就派上用场。还有一种情况，一个由图形用户界面（GUI）驱动的应用程序可能会提供一个“取消”按钮，以便用户可以终止后台某一线程正在执行的任务。这种情况下，主线程（控制图形用户界面）需要请求后台线程退出。

功能：
    - 线程可以通过pthread_cancel来请求取消同一进程中的其它线程
    - pthread_cancel并不等待线程终止，它仅仅提出请求
    
    #include <pthread.h>
    作用：
    * 取消一个执行中的线程(注意，这个仅仅是提出请求，而不等待线程终止。被请求的线程可以忽略取消或者控制如何被取消)
    int pthread_cancel(pthread_t thread);
    
    
    NAME
           pthread_cancel - 向线程发送取消请求
    
    SYNOPSIS
           #include <pthread.h>
    
           int pthread_cancel(pthread_t thread);
    
           Compile and link with -pthread.
    
    DESCRIPTION
           The  pthread_cancel()函数的作用是：向线程发送一个取消请求。目标线程是否以及何时响应取消请求取决于该线
           程控制的两个属性：cancelability state和type。
    
    
          一个线程的cancelability state, 由 pthread_setcancelstate(3)决定, 可以启用 (默认设置)或者禁用. 
          	 
          		如果线程已禁用取消，则取消请求将保持排队状态，直到线程启用取消。
          	 
          	 	如果线程已启用取消，则其可取消性类型将确定何时发生取消。
    
          线程的取消类型由 pthread_setcanceltype(3) 确定，可以是异步的或延迟的（新线程的默认设置）。 
    
    			异步可取消性意味着线程可以随时取消（通常是立即取消，但系统不保证这一点）。 
    
                延迟可取消性意味着取消将被延迟，直到线程下一次调用作为取消点的函数为止。 
    
                pthreads(7) 中提供了作为或可能是取消点的函数列表。 
    
           当对取消请求采取行动时，线程将执行以下步骤（按此顺序）：
    
            	1. 取消清理处理程序被弹出（与它们被推送的顺序相反）并被调用。 （请参阅 pthread_cleanup_push(3)。）
    
            	2. 以未指定的顺序调用特定于线程的数据析构函数。 （请参阅 pthread_key_create(3)。）
    
            	3. 线程终止。 （请参阅 pthread_exit(3)。） 
    
    
    	   上述步骤相对于pthread_cancel（）调用是异步发生的； pthread_cancel() 的返回状态只是通知调用者取消请求是否成功排队。
    
           取消的线程终止后，使用 pthread_join(3) 与该线程的连接获得 PTHREAD_CANCELED 作为线程的退出状态。 （使用线程加入是
           知道取消已完成的唯一方法。）
    
    RETURN VALUE
    		成功0，失败非0

线程甲可以通过函数 pthread\_cancel()向由 thread 指定的线程发送一个取消请求。发出取消请求后，函数 pthread\_cancel()当即返回，不会等待目标线程的退出。

接收到cancel请求的线程，怎么处理这个请求由它自己确定，或者忽略（当禁止取消时）、或者立即终止（当在取消点 或异步模式下）、或者继续运行至Cancelation-point（取消点，下面将描述），总之目标线程是否以及何时响应取消请求取决于该线 程控制的两个属性：cancelability state和type。

## 取消状态及类型 ##

NAME
           pthread_setcancelstate, pthread_setcanceltype - set cancelability state and type
    
    SYNOPSIS
           #include <pthread.h>
    
           int pthread_setcancelstate(int state, int *oldstate);
           int pthread_setcanceltype(int type, int *oldtype);
    
           Compile and link with -pthread.
    
    返回值
    	   若成功返回0；失败返回错误编号

函数 pthread\_setcancelstate()和 pthread\_setcanceltype()会设定标志，允许线程对取消请求的响应过程加以控制

函数 pthread\_setcancelstate()会将调用线程的取消性状态置为参数 state 所给定的值。该参数的值如下。

*  PTHREAD\_CANCEL\_DISABLE ：线程不可取消。如果此类线程收到取消请求，则会将请求挂起，直至将线程的取消状态置为启用。
 *  PTHREAD\_CANCEL\_ENABLE ：线程可以取消。这是新建线程取消性状态的默认值

线程的前一取消性状态将返回至参数 oldstate 所指向的位置。如果对前一状态没有兴趣，Linux 允许将 oldstate 置为 NULL。

如果线程的取消性状态为“启用”（PTHREAD\_CANCEL\_ENABLE），那么对取消请求的处理则取决于线程的取消性类型，该类型可以通过调用函数 pthread\_setcanceltype()时的参数type 给定。参数 type 有如下值：

*  PTHREAD\_CANCEL\_ASYNCHRONOUS：可能会在任何时点（也许是立即取消，但不一定）取消线程。这种类型的取消称为“异步取消”。异步取消的应用场景很少  
    PTHREAD\_CANCEL\_DEFERRED：（系统默认类型）取消请求保持挂起状态，直至到达取消点，才会取消

线程原有的取消类型将返回至参数 oldtype 所指向的位置。如果对前一类型没有兴趣，Linux 允许将 oldtype 置为 NULL。

> 当某线程调用 fork()时，子进程会继承调用线程的取消性类型及状态。而当某线程调用exec()时，会将新程序主线程的取消性类型及状态分别重置为 PTHREAD\_ CANCEL\_ NABLE和 PTHREAD\_CANCEL\_DEFERRED。

## 取消点 ##

*  概念：系统自定义了一些线程取消点。当一个线程接收到其他线程的取消请求时，如果还没有运行到取消点，该线程还是会继续运行，直到运行到某个取消点，线程才真正地被取消
 *  线程取消点技术也称为“推迟取消”

SUSv3 规定，实现若提供了表 32-1 中所列的函数，则这些函数必须是取消点。其中的大部分函数都有能力将线程无限期地堵塞起来:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]  
线程一旦收到取消请求，而且启用了取消性状态并将类型置为延迟，则其会在下次抵达取消点时终止。如果该线程尚未分离，那么为了防止其变为僵尸进程，必须由其他线程对其进行连接(join)。连接之后，返回至函数pthread\_join()中第二个参数的将是一个特殊值：PTHREAD\_CANCELED

看个例子：

static void *
    threadFunc(void *arg)
    {
        
        int j;
    
        printf("New thread started\n");     /* May be a cancellation point */
        for (j = 1; ; j++) {
        
            printf("Loop %d\n", j);         /* May be a cancellation point */
            sleep(1);                       /* A cancellation point */
        }
    
        /* NOTREACHED */
        return NULL;
    }
    int
    main(int argc, char *argv[])
    {
        
        pthread_t thr;
        int s;
        void *res;
    
        s = pthread_create(&thr, NULL, threadFunc, NULL);
        if (s != 0)
            errExitEN(s, "pthread_create");
    
        sleep(3);                           /* Allow new thread to run a while */
    
        s = pthread_cancel(thr);
        if (s != 0)
            errExitEN(s, "pthread_cancel");
    
        s = pthread_join(thr, &res);
        if (s != 0)
            errExitEN(s, "pthread_join");
    
        if (res == PTHREAD_CANCELED)
            printf("Thread was canceled\n");
        else
            printf("Thread was not canceled (should not happen!)\n");
    
        exit(EXIT_SUCCESS);
    }

## pthread\_testcancel ##

上面程序中，由 main()创建的线程会执行到属于取消点的函数（sleep()属于取消点，printf()可能也是），因而会接受取消请求。不过，假设线程执行的是一个不含取消点的循环（计算密集型［compute-bound］循环），这时，线程永远也不会响应取消请求

pthread\_testcancel()的目的很简单，就是产生一个取消点。线程如果已有出于挂起状态的取消请求，那么只要调用该函数，线程就会随之终止。

#include <pthread.h>
    void pthread_testcancel(void);

当线程执行的代码未包含取消点时，可以周期性地调用 pthread\_testcancel()，以确保对其他线程向其发送的取消请求做出及时响应

## 注册线程清理函数 ##

一旦有处于挂起状态的取消请求，线程在执行到取消点时如果只是草草收场，这会将共享变量以及 Pthreads 对象（例如互斥量）置于一种不一致状态，可能导致进程中其他线程产生错误结果、死锁，甚至造成程序崩溃。为规避这一问题，线程可以设置一个或多个清理函数，当线程遭取消时会自动运行这些函数，在线程终止之前可执行诸如修改全局变量，解锁互斥量等动作。

### 理论 ###

每个线程都可以拥有一个清理函数栈。当线程遭**取消**时，会沿该栈自顶向下依次执行清理函数，首先会执行最近设置的函数，接着是次新的函数，以此类推。当执行完所有清理函数后，线程终止。

void pthread_cleanup_push(void (*rtn)(void *), void *arg);
    // 其中参数 execute为0时，移除pthread_cleanup_push()压入（或者叫注册）的清理函数，当为非零时，表示执行pthread_cleanup_push()压入（或者叫注册）的清理函数。
    void pthread_clean_pop(int execute);

*  函数 pthread\_cleanup\_push()和 pthread\_cleanup\_pop()分别负责向调用线程的清理函数栈添加和移除清理函数，必须成对出现
 *  执行 pthread\_cleanup\_push()时给定的 arg 值，会作为调用清理函数时的参数。
 *  通常，线程如果在执行一段特殊代码时遭到取消，才需要执行清理动作。如果线程顺利执行完这段代码，那么久不需要清理。所以，每个对pthread\_cleanup\_push()的调用都会伴随着对pthread\_clean\_up的调用。此函数从清理函数栈中移除最顶层的函数。如果参数 execute 非零，那么无论如何都会执行清理函数。在函数未遭取消而又希望执行清理动作的情况下，这会非常方便

`rtn`调用时机：

*  执行`pthread_exit`时
 *  响应取消请求`pthread_cancle`时
 *  以非0参数调用`pthread_cleanup_pop`

注意：

*  如果线程只是由于简单的返回而终止的，则清除函数不会被调用。
 *  如果pthread\_cleanup\_pop被传递0参数，则清除函数不会被调用，但是会清除处于栈顶的清理函数。

### 实践 ###

#### `pthread_cleanup_pop`0表示从栈中移除，1表示从栈中弹出并执行 ####

> pthread\_cleanup\_pop(1);

#include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <zconf.h>
    
    void cleanup(void *arg)
    {
        
        printf("cleanup: %s\n", (char *)arg);
    }
    
    void * thr_fn1(void *arg)
    {
        
        printf("thread 1 start\n");
        pthread_cleanup_push(cleanup, "thread 1 first handler");
        pthread_cleanup_push(cleanup, "thread 1 second handler");
        printf("thread 1 push complete\n");
        pthread_cleanup_pop(1);  // 非0表示执行
        pthread_cleanup_pop(1);  //pthread_cleanup_push、 pthread_cleanup_pop必须成对出现
        return((void *)0);
    }
    
    int main(void)
    {
        
        int			err;
        pthread_t	tid1;
        void		*tret;
    
        err = pthread_create(&tid1, NULL, thr_fn1, (void *)0);
        if (err != 0){
        
            fprintf(stderr, "can't create thread 1");
            exit(err);
        }
    
        err = pthread_join(tid1, &tret);
        if (err != 0){
        
            fprintf(stderr, "can't join with thread 1");
            exit(err);
        }
        printf("thread 1 exit code %ld\n", (long)tret);
        
        exit(0);
    }

![在这里插入图片描述][20201126152217643.png_pic_center]

#include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <zconf.h>
    
    void cleanup(void *arg)
    {
        
        printf("cleanup: %s\n", (char *)arg);
    }
    
    void * thr_fn1(void *arg)
    {
        
        printf("thread 1 start\n");
        pthread_cleanup_push(cleanup, "thread 1 first handler");
        pthread_cleanup_push(cleanup, "thread 1 second handler");
        printf("thread 1 push complete\n");
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
        return((void *)0);
    }
    
    int main(void)
    {
        
        int			err;
        pthread_t	tid1;
        void		*tret;
    
        err = pthread_create(&tid1, NULL, thr_fn1, (void *)0);
        if (err != 0){
        
            fprintf(stderr, "can't create thread 1");
            exit(err);
        }
    
        err = pthread_join(tid1, &tret);
        if (err != 0){
        
            fprintf(stderr, "can't join with thread 1");
            exit(err);
        }
        printf("thread 1 exit code %ld\n", (long)tret);
    
        exit(0);
    }

![在这里插入图片描述][20201126152313328.png_pic_center]

*  `pthread_cleanup_push`和`pthread_cleanup_pop`必须成对出现
 *  `pthread_cleanup_pop`0表示从栈中移除，1表示从栈中弹出并执行
 *  执行顺序与注册顺序相反

> 父进程执行`pthread_exit`子进程还没有结束

#include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <zconf.h>
    
    void cleanup(void *arg)
    {
        
        printf("cleanup: %s\n", (char *)arg);
    }
    
    void * thr_fn1(void *arg)
    {
        
        printf("thread 1 start\n");
        pthread_cleanup_push(cleanup, "thread 1 first handler");
        pthread_cleanup_push(cleanup, "thread 1 second handler");
        printf("thread 1 push complete\n");
    
        sleep(5);
        printf("thread 1 pop start\n");
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
        printf("thread 1 pop complete\n");
        return((void *)0);
    }
    
    int main(void)
    {
        
        int			err;
        pthread_t	tid1;
    
        err = pthread_create(&tid1, NULL, thr_fn1, (void *)0);
        if (err != 0){
        
            fprintf(stderr, "can't create thread 1");
            exit(err);
        }
    
        sleep(1);
        printf("main cancel thread 1 start\n");
        err = pthread_cancel(tid1);
        if (err != 0){
        
            fprintf(stderr, "can't cancel thread 1");
            exit(err);
        }
        printf("main cancel thread 1 complete\n");
      // sleep(2);  // 不用担心主线程退出之后，清理函数不执行
        printf("main exit\n");
        exit(0);
    }

![在这里插入图片描述][20201126152849740.png_pic_center]

#### pthread\_exit提前退出，调用。 return提前退出，不调用 ####

> `pthread_exit`**提前退出**

#include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <zconf.h>
    #include <apue.h>
    
    void cleanup(void *arg)
    {
        
        printf("cleanup: %s\n", (char *)arg);
    }
    
    void * thr_fn1(void *arg)
    {
        
        printf("thread 1 start\n");
        pthread_cleanup_push(cleanup, "thread 1 first handler");
        pthread_cleanup_push(cleanup, "thread 1 second handler");
        printf("thread 1 push complete\n");
        pthread_exit((void *)0);
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
    }
    
    int main(void)
    {
        
        int			err;
        pthread_t	tid1;
        void		*tret;
    
        err = pthread_create(&tid1, NULL, thr_fn1, (void *)0);
        if (err != 0){
        
            fprintf(stderr, "can't create thread 1");
            exit(err);
        }
        err = pthread_join(tid1, &tret);
        if (err != 0){
        
            fprintf(stderr, "can't join with thread 1");
            exit(err);
        }
    
        //sleep(3);
        printf("main exit\n");
        exit(0);
    }

![在这里插入图片描述][20201126153638527.png_pic_center]

如果`pthread_exit`不是提前退出的话，不会调用

#include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <zconf.h>
    #include <apue.h>
    
    void cleanup(void *arg)
    {
        
        printf("cleanup: %s\n", (char *)arg);
    }
    
    void * thr_fn1(void *arg)
    {
        
        printf("thread 1 start\n");
        pthread_cleanup_push(cleanup, "thread 1 first handler");
        pthread_cleanup_push(cleanup, "thread 1 second handler");
        printf("thread 1 push complete\n");
    
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
        pthread_exit((void *)0);
    }
    
    int main(void)
    {
        
        int			err;
        pthread_t	tid1;
        void		*tret;
    
        err = pthread_create(&tid1, NULL, thr_fn1, (void *)0);
        if (err != 0){
        
            fprintf(stderr, "can't create thread 1");
            exit(err);
        }
        err = pthread_join(tid1, &tret);
        if (err != 0){
        
            fprintf(stderr, "can't join with thread 1");
            exit(err);
        }
    
       //sleep(3);
        printf("main exit\n");
        exit(0);
    }

![在这里插入图片描述][20201126153713108.png_pic_center]  
如果时`return`提前退出，也不会调用

#include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <zconf.h>
    #include <apue.h>
    
    void cleanup(void *arg)
    {
        
        printf("cleanup: %s\n", (char *)arg);
    }
    
    void * thr_fn1(void *arg)
    {
        
        printf("thread 1 start\n");
        pthread_cleanup_push(cleanup, "thread 1 first handler");
                pthread_cleanup_push(cleanup, "thread 1 second handler");
        printf("thread 1 push complete\n");
        if(1){
        
              return 0;
        }
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
    }
    
    int main(void)
    {
        
        int			err;
        pthread_t	tid1;
        void		*tret;
    
        err = pthread_create(&tid1, NULL, thr_fn1, (void *)0);
        if (err != 0){
        
            fprintf(stderr, "can't create thread 1");
            exit(err);
        }
        err = pthread_join(tid1, &tret);
        if (err != 0){
        
            fprintf(stderr, "can't join with thread 1");
            exit(err);
        }
    
     
        printf("main exit\n");
        exit(0);
    }

![在这里插入图片描述][20201126154153869.png_pic_center]

总的来说就是： `pthread_exit`提前退出，调用。 `return`提前退出，不调用

#include "apue.h"
    #include <pthread.h>
    
    void cleanup(void *arg)
    {
        
        printf("cleanup: %s\n", (char *)arg);
    }
    
    void * thr_fn1(void *arg)
    {
        
        printf("thread 1 start\n");
        pthread_cleanup_push(cleanup, "thread 1 first handler");
                pthread_cleanup_push(cleanup, "thread 1 second handler");
                        printf("thread 1 push complete\n");
                        if (arg)
                            return((void *)1);
                pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
        return((void *)0);
    }
    
    void *thr_fn2(void *arg)
    {
        
        printf("thread 2 start\n");
        pthread_cleanup_push(cleanup, "thread 2 first handler");
                pthread_cleanup_push(cleanup, "thread 2 second handler");
                        printf("thread 2 push complete\n");
                        if (arg)
                            pthread_exit((void *)2);
                pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
        return((void *)0);
    }
    
    int main(void)
    {
        
        int			err;
        pthread_t	tid1, tid2;
        void		*tret;
    
        err = pthread_create(&tid1, NULL, thr_fn1, (void *)1);
        if (err != 0)
            err_exit(err, "can't create thread 1");
        err = pthread_create(&tid2, NULL, thr_fn2, (void *)1);
        if (err != 0)
            err_exit(err, "can't create thread 2");
        err = pthread_join(tid1, &tret);
        if (err != 0)
            err_exit(err, "can't join with thread 1");
        printf("thread 1 exit code %ld\n", (long)tret);
    
    
    
        err = pthread_join(tid2, &tret);
        if (err != 0)
            err_exit(err, "can't join with thread 2");
        printf("thread 2 exit code %ld\n", (long)tret);
        exit(0);
    }

![在这里插入图片描述][20201126154422572.png_pic_center]

补充：

> 如果在`pthread_cancel`进程就已经死掉了，`pthread_cancel`进程会报错

#include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <zconf.h>
    #include <apue.h>
    
    void cleanup(void *arg)
    {
        
        printf("cleanup: %s\n", (char *)arg);
    }
    
    void * thr_fn1(void *arg)
    {
        
        printf("thread 1 start\n");
        pthread_cleanup_push(cleanup, "thread 1 first handler");
        pthread_cleanup_push(cleanup, "thread 1 second handler");
        printf("thread 1 push complete\n");
    
        //sleep(5);
        printf("thread 1 pop start\n");
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
        printf("thread 1 pop complete\n");
        return((void *)0);
    }
    
    int main(void)
    {
        
        int			err;
        pthread_t	tid1;
    
        err = pthread_create(&tid1, NULL, thr_fn1, (void *)0);
        if (err != 0){
        
            fprintf(stderr, "can't create thread 1");
            exit(err);
        }
    
        sleep(1);
        printf("main cancel thread 1 start\n");
        err = pthread_cancel(tid1);
        if (err != 0){
        
            err_exit(err, "can't create thread 2");
        }
        printf("main cancel thread 1 complete\n");
        sleep(2);
        printf("main exit\n");
        exit(0);
    }

![在这里插入图片描述][20201126153134767.png_pic_center]

# 总结 #

*  函数pthread\_cancle()允许某线程向另一线程发送取消请求，要求目标线程终止
 *  目标线程如何响应，取决于其取消性状态和类型。如果禁用线程的取消性状态，那么请求会保持挂起(pending)状态，直到将线程的取消性状态设置为启动。如果启用取消性状态，那么线程何时响应请求则依赖于取消性类型。如果类型为延迟取消，则在线程下一次调用某个取消点时，取消发生。如果为异步取消类型，取消动作随时可能发生（鲜有使用）
 *  线程可以设置一个清理函数栈，其中的清理函数属于由开发人员定义的函数，当线程遭到取消时，会自动调用这些函数以执行清理工作（例如，恢复共享变量状态，或解锁互斥量）。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221014/f2898fa87f2541dba696acd5d26ab8a3.png
[20201126152217643.png_pic_center]: /images/20221014/65662ce3a5554afcb2200bab434ec537.png
[20201126152313328.png_pic_center]: /images/20221014/d36ef2370a394f9c8f404ed9f49c2e14.png
[20201126152849740.png_pic_center]: /images/20221014/54243ddafe484578a0a7a9eb51fb909a.png
[20201126153638527.png_pic_center]: /images/20221014/3046822f03014f45a98a23b388350785.png
[20201126153713108.png_pic_center]: /images/20221014/afba880faa634395b48cf0c1f56b5a5e.png
[20201126154153869.png_pic_center]: /images/20221014/8c13403dafef4fdd815b4dec99b79dc9.png
[20201126154422572.png_pic_center]: /images/20221014/20c474dca0f44d0f83d4009b61a493d8.png
[20201126153134767.png_pic_center]: /images/20221014/0acdd39a68e54e149e49e4be8784ea6f.png