分离属性，线程取消例程函数，线程响应取消行为的类型

左手的ㄟ右手 2022-12-11 13:56 119阅读 0赞

四、分离属性。  
1、什么是分离属性？  
首先分离属性是线程的一个属性，有了分离属性的线程，不需要别的线程去接合自己。（自己会回收自己的资源）  
但是虽然说是分离，但是进程退出了，该线程还是要退出的。

分离属性线程 -> 不需要pthread\_join()去接合线程，即使调用也会返回。  
非分离属性线程 -> 需要pthread\_join()去接合线程 -> 默认创建的普通属性就是非分离属性。

2、如何创建出分离属性的线程？  
方法一：添加一个分离属性到一个属性变量，然后使用属性变量去创建一个子线程，那么创建出来的子线程就是具有分离属性的线程。

1）定义一个属性变量 -> 数据类型： pthread\_attr\_t  
pthread\_attr\_t attr;

2）初始化属性变量。 -> pthread\_attr\_init() -> man 3 pthread\_attr\_init  
功能：initialize thread attributes object  
头文件：  
\#include <pthread.h>

原型：  
int pthread\_attr\_init(pthread\_attr\_t \*attr);

参数：  
attr： 需要初始化的属性变量的地址。

返回值：  
成功：0  
失败：非0

3）添加分离属性到属性变量中。 -> pthread\_attr\_setdetachstate() -> man 3 pthread\_attr\_setdetachstate  
头文件：  
\#include <pthread.h>

原型：  
int pthread\_attr\_setdetachstate(pthread\_attr\_t \*attr, int detachstate);

参数：  
attr：需要添加属性的属性变量的地址  
detachstate：  
PTHREAD\_CREATE\_DETACHED -> 分离属性  
PTHREAD\_CREATE\_JOINABLE -> 非分离属性  
  
返回值：  
成功：0  
失败：非0

4）利用分离属性去创建子线程。  
pthread\_create(&tid,&attr,xxxx);

5）那么创建出来的线程是分离属性的线程，在线程结束时，会自动回收自己的资源。

6）销毁属性变量。 -> pthread\_attr\_destroy() -> man 3 pthread\_attr\_destroy  
头文件：  
\#include <pthread.h>  
原型：  
int pthread\_attr\_destroy(pthread\_attr\_t \*attr);

参数：  
attr：需要销毁的属性变量的地址

返回值：  
成功：0  
失败：非0

练习1： 验证一个分离属性的线程退出时，主线程如果还接合它，接合函数会阻塞吗？  
练习2： 验证一个分离属性的线程工作时间比较长，主线程工作时间短，主线程工作完导致进程退出，子线程会退出吗？

\#include <pthread.h>  
\#include <stdio.h>  
\#include <unistd.h>

//子线程正常做任务，正常退出即可。  
void \*my\_fun(void \*arg) //工作5S，然后自己退出，自己回收自己的资源  
\{  
int i;  
for(i=0;i<5;i++)  
\{  
printf("%d\\n",i);  
sleep(1);  
\}  
\}

int main(int argc,char \*argv\[\])  
\{  
//1、 定义一个属性变量。  
pthread\_attr\_t attr;  
  
//2、 初始化属性变量。  
pthread\_attr\_init(&attr);  
  
//3、 添加分离属性到属性变量中。  
pthread\_attr\_setdetachstate(&attr,PTHREAD\_CREATE\_DETACHED);  
  
//4、 使用该属性变量去创建一条线程。  
pthread\_t tid;  
pthread\_create(&tid,&attr,my\_fun,NULL);  
  
//5、 故意还去接合线程  
int ret;  
ret = pthread\_join(tid,NULL);  
if(ret == 0)  
\{  
printf("pthread join success!\\n");  
\}  
else\{  
printf("pthread join error!\\n");  
\}  
  
//6、 睡眠2S  
sleep(2);  
  
return 0; //进程退出了，所有的线程（不管是不是分离的）都会退出。  
\}

结果：  
pthread join error! -> 一运行pthread\_join()，函数就会马上返回失败！  
0  
1 -> 2S后，进程退出，会导致分离属性的线程也会退出。

方法二：先创建一条普通属性的线程，在子线程调用设置自己为分离属性的函数即可。  
1）设置线程本身属性为分离属性。 -> pthread\_detach() -> man 3 pthread\_detach  
功能： detach a thread  
//设置分离属性给线程。

头文件：  
\#include <pthread.h>  
  
原型：  
int pthread\_detach(pthread\_t thread);

参数：  
thread： 需要设置分离属性的线程。

返回值：  
成功：0  
失败：非0

2）获取线程的ID号。 -> pthread\_self() -> man 3 pthread\_self  
功能： obtain ID of the calling thread  
//获取一个正在运行的线程的ID号。

头文件：  
\#include <pthread.h>

原型：  
pthread\_t pthread\_self(void);

返回值：线程的ID号。

练习3：使用方法二设置线程分离属性。

\#include <pthread.h>  
\#include <stdio.h>  
\#include <unistd.h>

//子线程正常做任务，正常退出即可。  
void \*my\_fun(void \*arg) //工作5S，然后自己退出，自己回收自己的资源  
\{  
//目前为止，我还是非分离的线程  
//3. 设置分离属性给自己。  
int ret;  
ret = pthread\_detach(pthread\_self());  
printf("ret = %d\\n",ret);  
  
int i;  
for(i=0;i<5;i++)  
\{  
printf("%d\\n",i);  
sleep(1);  
\}  
\}

int main(int argc,char \*argv\[\])  
\{  
//1、 使用普通属性去创建一条线程。  
pthread\_t tid;  
pthread\_create(&tid,NULL,my\_fun,NULL);  
  
//2、 睡眠2S  
sleep(2);  
  
//4、 故意还去接合线程  
int ret;  
ret = pthread\_join(tid,NULL); //主线程join的时候已经知道线程是分离属性的了，所以返回失败  
if(ret == 0)  
\{  
printf("pthread join success!\\n");  
\}  
else\{  
printf("pthread join error!\\n");  
\}  
  
return 0; //进程退出了，所有的线程（不管是不是分离的）都会退出。  
\}

五、 线程的取消。  
1、一般主线程不用于处理任务，只是控制子线程状态，例如取消，接合 -> pthread\_cancel() -> man 3 pthread\_cancel  
主线程 -> 发送取消请求 -> 子线程 -> 收到取消请求 -> 子线程就会退出。

功能： send a cancellation request to a thread  
//发送一个取消请求给线程

头文件：  
\#include <pthread.h>

原型：  
int pthread\_cancel(pthread\_t thread);

参数：  
thread： 需要收到取消请求的线程ID号。

返回值：  
成功：0  
失败：非0

补充： 默认普通属性的线程可以响应取消请求。

2、 关于线程取消案例。  
尝试让主线程发送一个取消请求给子线程，看看子线程会不会被取消掉。  
  
\#include <pthread.h>  
\#include <stdio.h>  
\#include <unistd.h>

//子线程负责工作即可。  
void \*fun(void \*arg)  
\{  
//线程默认情况： 非分离 能响应取消 延迟取消

int i;  
for(i=0;i<5;i++)  
\{  
printf("%d\\n",i);  
sleep(1);  
\}  
\}

int main(int argc,char \*argv\[\])// 看看小孩还会继续工作？  
\{  
//1. 创建一个子线程  
pthread\_t tid;  
pthread\_create(&tid,NULL,fun,NULL);  
  
//2. 等待几秒，让孩子工作几秒  
sleep(2);  
  
//3. 发送一个取消请求给小孩  
pthread\_cancel(tid);  
  
//4. 小孩退出了，需要去接合线程  
pthread\_join(tid,NULL);  
  
return 0;  
\}

结果：  
gec@ubuntu:/mnt/hgfs/GZ2057/09 系统编程/06/code$ ./cancel\_test  
0  
1

子线程只工作了2s ,就退出。

六、研究线程响应取消的状态。 -> pthread\_setcancelstate() -> man 3 pthread\_setcancelstate  
默认情况，线程都是能响应取消。  
如果线程设置了不能响应取消的请求，那么如果将收到了取消的请求，也不会被取消。

1、 函数功能介绍：  
功能： set cancelability state  
//设置线程的取消状态

头文件：  
\#include <pthread.h>

原型：  
int pthread\_setcancelstate(int state, int \*oldstate);

参数：  
state：  
PTHREAD\_CANCEL\_ENABLE -> 能响应 -> 线程默认属性  
PTHREAD\_CANCEL\_DISABLE -> 不能响应  
  
oldstate： 保留之前的状态，如果不关心，则填NULL。

返回值：  
成功：0  
失败：非0

2、 案例：  
创建一个子线程，然后设置不能响应取消行为给线程，然后再发送一个取消请求给线程，看看线程会不会提前退出。

\#include <pthread.h>  
\#include <stdio.h>  
\#include <unistd.h>

//子线程负责工作即可。  
void \*fun(void \*arg)  
\{  
//1. 默认情况下，都是能响应。  
//2. 设置自己为不能响应取消。  
pthread\_setcancelstate(PTHREAD\_CANCEL\_DISABLE,NULL);  
  
int i;  
for(i=0;i<5;i++)  
\{  
printf("%d\\n",i);  
sleep(1);  
\}  
\}

int main(int argc,char \*argv\[\])// 看看小孩还会继续工作？  
\{  
//1. 创建一个子线程  
pthread\_t tid;  
pthread\_create(&tid,NULL,fun,NULL);  
  
//2. 等待几秒，让孩子工作几秒  
sleep(2);  
  
//3. 发送一个取消请求给小孩  
pthread\_cancel(tid);  
printf("I send cancel to you!\\n");  
  
//4. 小孩退出了，需要去接合线程  
pthread\_join(tid,NULL);  
  
return 0;  
\}

结果：  
gec@ubuntu:/mnt/hgfs/GZ2057/09 系统编程/06/code$ ./cancel\_test  
0  
1  
I send cancel to you!  
2  
3  
4

小孩能够正常工作5S，不能被取消。

练习4： 验证以下的结论是对的：  
If a cancellation request is received, it is blocked until cancelability is enabled.  
//在不能响应取消请求的情况下，如果收到了一个取消请求，那么这个取消请求会阻塞到能响应取消为止。

\#include <pthread.h>  
\#include <stdio.h>  
\#include <unistd.h>

void \*fun(void \*arg)  
\{  
//1. 设置不能响应  
pthread\_setcancelstate(PTHREAD\_CANCEL\_DISABLE,NULL);

int i;  
for(i=10;i>0;i--)  
\{  
printf("disable cancel!\\n");  
sleep(1);  
\} //主线程给自己发取消请求时，我是处于一个不能响应取消行为的状态  
  
//2. 设置为能响应。  
pthread\_setcancelstate(PTHREAD\_CANCEL\_ENABLE,NULL); -> 只要设置能响应，就会马上响应。  
  
for(i=10;i>0;i--)  
\{  
printf("enable cancel!\\n");  
sleep(1);  
\}  
\}

int main(int argc,char \*argv\[\])  
\{  
//1. 创建普通属性线程  
pthread\_t tid;  
pthread\_create(&tid,NULL,fun,NULL);  
  
//2. 睡眠2S后，发送取消请求子线程  
sleep(2);  
pthread\_cancel(tid);  
  
//3. 接合线程  
pthread\_join(tid,NULL);  
  
return 0;  
\}

七、线程响应取消行为的类型。 -> pthread\_setcanceltype() -> man 3 pthread\_setcanceltype

1、 函数功能介绍：  
状态： enable:能响应，disable:不能响应。  
类型： 基于能响应的情况，又分为立即取消和延迟取消。  
  
功能：set cancelability type  
//设置取消类型。

头文件：  
\#include <pthread.h>

原型：  
int pthread\_setcanceltype(int type, int \*oldtype);

参数：  
type：  
PTHREAD\_CANCEL\_DEFERRED -> 延迟取消  
\-> 收到取消请求后，不能立即响应，而是遇到取消取消点函数才会响应  
\-> 线程默认属性就是延迟取消。

PTHREAD\_CANCEL\_ASYNCHRONOUS -> 立即取消  
oldtype： 保留之前的状态，如果不关心，则填NULL。

返回值：  
成功：0  
失败：非0

取消点函数有哪些？ -> man 7 pthreads  
usleep()  
sleep()  
fprintf()  
fputc()  
printf()

2、 写一个明显的延迟取消案例。  
\#include <pthread.h>  
\#include <stdio.h>  
\#include <unistd.h>

void \*fun(void \*arg)  
\{  
//默认： 能响应 延迟取消  
//0. 早就收到取消。  
  
//1. 想办法让线程不要遇到取消点函数。  
int i,j;  
for(i=0;i<100000;i++)  
\{  
for(j=0;j<100000;j++)  
\{  
  
\} //持续一段时间  
\}  
  
//2. 故意遇到取消点。  
while(1)  
\{  
fputc('a',stderr); //把'a'放在标准出错的缓冲区 fputc是取消点函数，所以程序运行到这里，就会响应取消。  
printf("helloworld!\\n");  
\}  
\}

int main(int argc,char \*argv\[\])  
\{  
//1. 创建子线程。  
pthread\_t tid;  
pthread\_create(&tid,NULL,fun,NULL);  
  
//2. 发送一个取消请求给子线程。  
pthread\_cancel(tid);  
printf("I send cancel to thread!\\n");  
  
//3. 接合线程。  
pthread\_join(tid,NULL);  
  
return 0;  
\}

八、线程取消例程函数。  
1、什么是线程取消例程函数？  
当线程收到取消请求时，先不要马上响应取消请求，而是执行一个例程函数先，执行完之后，再响应取消。

2、 为什么要使用取消例程函数？  
为了防止线程带着一些公共资源时被取消掉。  
如果你带着资源退出，那么其他的线程就无法再次使用该资源。

3、 如何实现？  
1）在线程内部说明例程函数是哪个？ -> pthread\_cleanup\_push() -> man 3 pthread\_cleanup\_push  
功能： push thread cancellation clean-up handlers  
头文件：  
\#include <pthread.h>

原型：  
void pthread\_cleanup\_push(void (\*routine)(void \*),void \*arg);

参数：  
routine：线程取消例程函数 -> 必须是： void fun(void \*arg)  
arg：传递给取消例程函数的参数，如果不需要，则填NULL。

返回值：无。

回顾学习过的例程函数：  
信号处理函数： void fun( int sig)  
线程例程函数： void\* fun(void\* arg)  
取消例程函数： void fun(void\* arg)

2）删除例程函数 -> pthread\_cleanup\_pop() -> man 3 pthread\_cleanup\_pop  
功能： pop thread cancellation clean-up handlers  
头文件：  
\#include <pthread.h>

原型：  
void pthread\_cleanup\_pop(int execute);

参数：  
execute： 非0 -> 删除时，先执行一遍函数，再删除。  
0 -> 直接删除。

返回值：无

模型：  
//取消例程函数  
void cancel\_fun(void \*arg)  
\{

子线程：  
void \*thread\_func(void \*arg)  
\{  
//将来我收到取消请求，先执行cancel\_fun函数，再响应取消。  
pthread\_cleanup\_push(cancel\_fun,NULL);

.....;  
.....;  
.....; <--- 收到了取消请求  
.....;

//删除取消例程函数  
pthread\_cleanup\_pop(0);  
\}

基于以上模型，有以下几种情况：  
1）线程运行后，收到了取消请求。  
执行cancel\_fun这个函数 -> 响应取消 -> 线程提前退出  
（已经帮你删除掉cancel\_fun了，所以你的程序无法执行到后面的删除函数。所以后面的删除函数，无论参数是0还是非0，都不会再次执行 cancel\_fun）  
  
2）线程运行后，一直都没有收到取消请求。  
删除时： pthread\_cleanup\_pop(0); -> 参数是0 -> 直接删除。

3）线程运行后，一直都没有收到取消请求。  
删除时： pthread\_cleanup\_pop(1); -> 参数是非0 -> 先执行一遍cancel\_fun() -> 再删除。

练习5： 子线程收到主线程给自己发送的取消请求时，不要马上取消，而是先打印一句话"I recv cancel"，再响应取消请求。  
顺便使用这个练习，验证以上的三种情况。

\#include <pthread.h>  
\#include <stdio.h>  
\#include <unistd.h>

void func(void \*arg)  
\{  
printf("I recv cancel\\n");  
\}

void \*my\_fun(void \*arg)  
\{  
//1. 将来收到取消请求，先执行线程取消例程函数。  
pthread\_cleanup\_push(func,NULL);  
  
//2. 子线程开始工作。  
int i;  
for(i=0;i<10;i++)  
\{  
printf("helloworld!\\n");  
sleep(1);  
\}  
  
//3. 删除函数。  
pthread\_cleanup\_pop(2); //删除时，不会执行。  
\}

int main(int argc,char \*argv\[\])  
\{  
//1. 创建一个线程。  
pthread\_t tid;  
pthread\_create(&tid,NULL,my\_fun,NULL);  
  
//2. 3S后，发送一个取消请求给子线程。  
//sleep(3);  
//pthread\_cancel(tid);  
//printf("I send cancel to child thread!\\n");  
  
//3. 接合线程  
pthread\_join(tid,NULL);  
  
return 0;  
\}

A cancellation clean-up handler is popped from the stack and executed in the following circumstances:  
//线程取消例程函数被删除并且会被执行以下几种情况：

1. When a thread is canceled, all of the stacked clean-up handlers are popped and executed in the reverse of the order in which they were pushed onto the stack.  
//当你收到了一个取消请求时，会执行一遍例程函数，并删除。

2. When a thread terminates by calling pthread\_exit(3), all clean-up handlers are executed as described in the preceding point.  
如果线程因为调用pthread\_exit()函数而退出时，会执行一遍例程函数，并删除。

(Clean-up handlers are not called if the thread terminates by performing a return from the thread start function.)  
如果线程因为执行return语句而退出，则例程函数不会执行，但是会删除。

3. When a thread calls pthread\_cleanup\_pop() with a nonzero execute argument, the top-most clean-up handler is popped and executed.  
//当线程执行pthread\_cleanup\_pop()去删除线程例程函数时，携带了一个非0的参数，那么也会执行一遍并删除。