【Linux多线程】线程的终止、等待和分离

于 2024-06-05 23:28:01 发布
阅读量1.1k 收藏 31
点赞数 17
分类专栏： linux操作系统 文章标签： linux java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62987647/article/details/139474911
版权

文章目录

线程终止

下面给出终止线程的三种方式：

  1. 正常退出：
    • 线程执行完它的函数之后return自动结束
    • 线程显示调用pthread_exit函数退出
  2. 强制终止：
    • 一个线程可以被另一个线程通过pthread_cancel函数强制退出
  3. 进程终止：
    • 一个进程终止，那么该进程的所有线程都会终止

下面将分别模拟这三种终止线程的方式：

正常退出

return 退出

给出下面代码模拟线程return终止

#include <pthread.h>
#include <iostream>
#include <unistd.h>
#include <string.h>
using namespace std;

void *rout(void *arg)
{
    int cnt = 3;
    while (cnt--)
    {
        cout << "thread id :  " << pthread_self() << "  i am thread num:  " << *(int *)arg << endl;
        sleep(1);
    }
    cout << "phread end....." << endl;
    sleep(1);
    return NULL;
}

int main()
{
    pthread_t tid;
    int num = 10;
    int res = pthread_create(&tid, NULL, rout, (void *)(&num));
    pthread_join(tid, NULL); // 等待线程结束
    sleep(20);
    cout << "wait success! main thread end!" << endl;
    return 0;
}

在这里插入图片描述
观察上面代码运行情况，发现当线程return之后确实被终止了（上图多出来一个线程是库里面的管理线程，不必理会）。

pthread_exit函数终止线程

pthread-exit函数用于终止当前线程
函数原型：

void pthread_exit(void *value_ptr);
  • value_ptr是一个任意类型的指针，表示线程的退出状态。其它线程可以通过pthread_join函数获取这个状态

给出下面代码观察线程终止

#include <pthread.h>
#include <iostream>
#include <unistd.h>
#include <string.h>
using namespace std;

void *rout(void *arg)
{
    int cnt = 3;
    int *status = new int(20);
    while (true)
    {
        cout << "thread id :  " << pthread_self() << "  i am thread num:  " << *(int *)arg << endl;
        sleep(1);
        if (cnt == 0)
        {
            cout << "phread exit....." << endl;
            pthread_exit((void *)(status));
        }
        cnt--;
    }
    // cout << "phread end....." << endl;
    // sleep(1);
    return NULL;
}

int main()
{
    pthread_t tid;
    int num = 10;
    int res = pthread_create(&tid, NULL, rout, (void *)(&num));
    void *status = NULL;
    pthread_join(tid, &status); // 等待线程结束
    sleep(5);
    cout << "wait success! main thread end! status: " << *(int *)(status) << endl;
    return 0;
}

在这里插入图片描述
需要注意，pthread_exit或者return返回的指针指向的内存单元应该是全局的，因为线程终止之后其函数栈帧会销毁，之后才会返回一个void*指针。

pthread_cancel强制终止线程

功能：取消一个执行中的线程
函数原型：

int pthread_cancel(pthread_t thread);
  • thread表示要删除的线程id(用户级)
  • 成功返回0，否则返回错误码

给出代码样例，观察pthread_cancel函数的使用

#include <pthread.h>
#include <iostream>
#include <unistd.h>
#include <string.h>
using namespace std;

void *rout(void *arg)
{
    int cnt = 3;
    int *status = new int(20);
    while (true)
    {
        cout << "thread id :  " << pthread_self() << "  i am thread num:  " << *(int *)arg << endl;
        sleep(1);
        // if (cnt == 0)
        // {
        //     cout << "phread exit....." << endl;
        //     pthread_exit((void *)(status));
        // }
        // cnt--;
    }
    // cout << "phread end....." << endl;
    // sleep(1);
    return NULL;
}

int main()
{
    pthread_t tid;
    int num = 10;
    int res = pthread_create(&tid, NULL, rout, (void *)(&num));
    void *status = NULL;

    sleep(5);
    pthread_cancel(tid); // 强制终止tid
    cout << "thread is end" << endl;
    pthread_join(tid, &status); // 等待线程结束
    sleep(3);
    cout << "wait success! main thread end! status: " << *(int *)(status) << endl;
    return 0;
}

在这里插入图片描述
在主线程中调用pthread_cancel函数强制终止了执行rout函数的线程。

进程终止

进程终止，该进程的所有线程都终止。比如在函数中调用exit终止进程。

void *rout(void *arg)
{
    int cnt = 3;
    int *status = new int(20);
    while (true)
    {
        cout << "thread id :  " << pthread_self() << "  i am thread num:  " << *(int *)arg << endl;
        sleep(1);
        if (cnt == 0)
        {
            cout << "phread exit....." << endl;
            exit(0);
        }
        cnt--;
    }
    return NULL;
}

一旦调用exit或者异常而终止进程，该进程的所有线程都玩完。道理很简单，这里就不做演示了。

线程等待

为什么需要等待线程？

其实已经退出的线程并没有完全“结束”，其栈帧并没有随着线程终止马上就释放，仍然在进程的地址空间里。并且，如果不对这些已经终止但是还没有被释放空间的线程做处理，往后继续创建新线程都不会复用前面退出线程的地址空间，这就造成了资源的浪费。这种情况其实非常像我们之前谈过的僵尸进程问题。

等待线程终止就是提醒内核可以释放这个线程的资源了。等待线程终止其实也是为了确保线程完成任务。有时主线程或者其他线程需要等待某一个线程任务完成之后才能继续执行。等待一个线程结束，其实就是让终止的线程退出时“通知”一下其它线程，可以不关心退出线程的返回结果。此外，等待线程终止在某些情况下能保证数据的完整性，比如线程一处理上半段数据，线程二处理下半段数据，如果其中任何一个线程没有终止，那总数据就会不完整。

为了实现线程终止时的等待问题，linux提供了pthread_join函数。

pthread_join函数

作用：阻塞调用该函数线程，直到目标线程终止。
函数原型：

#include<pthread.h>
int pthread_join(pthread_t thread,void** retval);

在这里插入图片描述
其中：

  • thread表示所等待线程的线程标识符
  • retval是一个输出型参数，指向等待线程的退出信息
  • 成功返回0，否则返回错误码

值得注意的是，线程终止方式的不同，其通过pthread_join得到的退出信息也就不同。比如：

  1. 目标线程通过return 终止（或者是pthread_exit），retval所指向的单元里存放的就是目标线程执行函数的返回值。
    观察下面代码，分析线程return终止时，pthread_join得到的返回值
#include <pthread.h>
#include <iostream>
#include <unistd.h>
#include <string.h>
using namespace std;

void *rout(void *arg)
{
    int cnt = 3;
    int *status = new int(20);
    int num = 20;
    while (cnt--)
    {
        cout << "thread id :  " << pthread_self() << "  i am thread num:  " << *(int *)arg << endl;
        sleep(1);
    }
    // pthread_exit((void *)status);
    return (void *)status;
}

int main()
{
    pthread_t tid;
    int num = 10;
    int res = pthread_create(&tid, NULL, rout, (void *)(&num));
    void *status = NULL;
    cout << "main pthread wait...." << endl;
    pthread_join(tid, &status); // 等待线程结束
    sleep(3);
    cout << "wait success! main thread end! status: " << *(int *)(status) << endl;
    return 0;
}

在这里插入图片描述

  1. 如果线程是被别的线程通过调用pthread_cancel函数强制终止掉，retval所指向单元存放的就是常数PTHREAD_ CANCELED。

给出代码样例观察结果：

#include <pthread.h>
#include <iostream>
#include <unistd.h>
#include <string.h>
using namespace std;

void *rout(void *arg)
{
    int cnt = 3;
    int *status = new int(20);
    int num = 20;
    while (cnt--)
    {
        cout << "thread id :  " << pthread_self() << "  i am thread num:  " << *(int *)arg << endl;
        sleep(1);
    }
    pthread_exit((void *)status);
    // return (void *)status;
}

int main()
{
    pthread_t tid;
    int num = 10;
    int res = pthread_create(&tid, NULL, rout, (void *)(&num));
    void *status = NULL;
    sleep(2);
    pthread_cancel(tid);
    pthread_join(tid, &status); // 等待线程结束
    if (status == PTHREAD_CANCELED)
    {
        cout << "pthread is cancel" << endl;
    }
    return 0;
}

在这里插入图片描述
retval所指向单元存放的就是常数PTHREAD_ CANCELED得证。

  1. 如果不关心某一个线程的退出信息，可以return NULL。比如：
void* thread_function(void* arg) {
    // 线程的工作
    printf("Thread is running\n");
    return NULL;
}

总结：

分离线程

分离线程实际上是线程的一种状态，这种状态表示该进程不需要被等待，且线程退出后会自动释放资源。对于主线程来说，有些线程独立执行任务，其它线程没有必要再调用pthread_join阻塞等待。这样提升了整体的效率。一般来说，创建的新线程默认都是joinable的，也就是需要被等待的，我们可以通过pthread_detach函数来改变这一性质。

pthread_detach函数

功能：分离一个目标线程，使该线程终止后自动释放资源，不需要被等待
函数原型：

#include<pthread.h>
int pthread_detach(pthread_t thread);
  • thread表示分离的目标线程，也可以是调用该函数的线程本身
  • 成功放回0，否则-1

给出代码样例，观察pthread_detach函数的使用

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
using namespace std;

void *thread_run(void *arg)
{
    pthread_detach(pthread_self());
    printf("%s\n", (char *)arg);
    return NULL;
}

int main(void)
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, thread_run, (void *)"thread1 run...") != 0)
    {
        printf("create thread error\n");
        return 1;
    }

    int ret = 0;
    sleep(1); // 很重要，要让线程先分离，再等待

    if (pthread_join(tid, NULL) == 0)
    {
        printf("pthread wait success\n");
        ret = 0;
    }
    else
    {
        printf("pthread wait failed\n");
        ret = 1;
    }
    return ret;
}

在这里插入图片描述
分析上述代码，因为执行thread_run函数的线程设置成了分离状态，函数结束之后自动释放资源。此时再去用pthread_join函数去等待这个线程就会得到返回值0。

稻草人敲代码
关注
  • 17
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux系统编程36：多线程之线程控制之pthread线程库(线程创建，终止，等待和分离)
快乐江湖的博客
04-30 570
文章目录（1）POSIX线程库（2）pthread_create——创建线程A：关于Linux线程的再理解B：线程ID及地址空间布局（3）pthread_exit——线程终止（4）pthread_join——线程等待（5）pthread_detach——线程分离 （1）POSIX线程库 前面说过，在Linux中是用进程模拟线程的，所以就不会用形如fork()这类的系统调用提供给我们用来专门控制线程。所以要实现多线程，就要使用到库函数，这里面比较底层的是POSIX线程库，所以它就是产生的就是用户级别的线程，其
Linux线程的终止
shbj的博客
01-03 2482
Linux线程的终止 1.线程终止的三种情况。 线程从启动例程中简单返回（return)。 线程被同一进程中的其它线程取消。 线程调用pthread_exit()方法。 1.线程终止，并返回数据。 void pthread_exit(void *retval); 2.取消线程。 int pthread_cancel(pthread_t thread); 3.线程清理处理程序。 void pthread_cleanup_push(void (*routine)(void *),void *arg);
Linux 多线程环境下 进程线程终止函数小结
weixin_34218579的博客
10-11 144
pthread_kill： pthread_kill与kill有区别，是向线程发送signal。，大部分signal的默认动作是终止进程的运行，所以，我们才要用signal()去抓信号并加上处理函数。 int pthread_kill(pthread_t thread, int sig); 向指定ID的线程发送sig信号，如果线程代码内不做处理，则按照信号默认的行为影响整个进程，也就...
linux线程系列（4）线程终止
洪流之源
06-01 1399
一、主动终止 线程的执行函数中调用return语句 调用pthread_exit() 二、被动终止 1、线程可以被同一进程的其他线程取消，其它线程调用pthread_cancel(pthid)。 2、线程终止的3种方式 #include int pthread_cancel(pthread_t tid); void pthread_exit(void *retval); i
Linux线程-终止
系统运维
09-19 85
在前文讨论了线程创建的一些基本东西，这里讨论有哪些方法可以使线程终止，线程终止又是如何与创建所需的参数进行关联的。 一，正常终止 线程在执行完成之后，正常终止。 二，线程取消 2.1 线程取消的定义 一般情况下，线程在其主体函数退出的时候会自动终止，但同时也可以因为接收到另一个线程发来的终止（取消）请求而强制终止。 2.2 线程取消的语义 线程取消的方法是向目标线程发Ca...
windows和linux下等待线程的退出
Jaylon的专栏
02-22 1452
在linux上，创建一个线程然后在主进程中等待线程的退出，系统提供的api是比较显而易见的，创建线程使用pthread_create，线程退出使用pthread_exit，主线程等待线程退出使用pthread_join，下面就是在等待一个睡眠5S的线程退出例子，我们也可以获取到线程退出时传递的一些消息。 #include #include #include #include void
Linux-线程理解，线程创建，终止，等待与分离
mxrrr_sunshine的博客
04-19 421
Linux下线程在Linux下，线程被称为轻量级进程。也就是说，Linux下是用进程模拟线程的。每一个用户态线程，在内核中都对应一个调度实体，也拥有自己的进程描述符。 在认识线程之前，一个进程对于内核中的一个进程描述符，对于一个进程id。但是现在引入线程的概念之后，情况发生了变化，一个用户进程下管辖了N个用户态线程，每个线程作为一个独立的调度实体在内核态都有自己的进程描述符，进程和内核的描述符就变
linux中的线程（创建，等待，终止，分离，同步与互斥）
dai_wen的博客
04-09 245
一、linux中最常见的面试题 《1》问： 什么是进程？什么是线程？二者有何关系？ 答：线程是一个PCB，进程是一个PCB组；进程是一个程序运行的实体，每个进程都有它自己的内存地址段，换句话说，进程时执行中的程序，而程序是由多个代码段的集合，一般加载到内存中，是一个没有生命的实体，只有处理器赋予生命时，它才能成为一个活动的实体，另外，进程是指在系统中正在运行的一个应用程序，主要负责资源的分配和...
Linux 多线程原理深剖
最新发布
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
Linux多线程编程手册
04-08
Linux多线程编程手册详细介绍了两种线程API：Solaris线程API和pthread API。 Solaris线程API是Sun Microsystems开发的一种多线程库，它为Solaris操作系统提供了创建、管理和同步线程的功能。pthread API，又称POSIX...
Linux线程退出方式总结(推荐)
01-11
在编写多线程代码时，经常面临线程安全退出的问题。 一般情况下，选择检查标志位的方式： 在线程的while循环中，执行完例程后，都对标志位进行检查，如果标志位指示继续执行则再次执行例程，如果标志位设置为退出状态，则跳出循环，结束线程的运行。 这个标志位需要主线程（或其他线程）设置，设置后，主线程调用pthread_join接口进入休眠（接口参数指定了等待的线程控制指针），子线程退出后，主线程会接收到系统的信号，从休眠中恢复，这个时候就可以去做相关的资源清除动作。 这个方法可以保证子线程完全退出，主线程再去做相关的资源清除操作 时序图如下 但是某些应用中，或许会发生下面情况： 子线程
linux等待线程的结束,Windows和Linux上分别怎样实现等待某个线程结束？---用WaitForSingleObject和pthread_join...
weixin_30245667的博客
05-06 261
Windows和Linux上分别怎样实现等待某个线程结束呢， 我们先看Windows的情形， 直接上代码：#include #include DWORD WINAPI Fun1Proc(LPVOID lpParameter){int i = 0;for(i = 0; i < 100; i++){cout << "son thread" << i + 1 <&lt...
linux线程等待与分离
baobao1767640830的博客
05-19 208
线程等待原因 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。创建新的线程不会复用刚才退出线程的地址空间。 线程等待函数：pthread_join （1）功能：等待线程结束 （2）原型：int pthread_join(pthread_t pthread, void **value_ptr); （3）参数： a.thread：线程ID； b.Value_ptr：它指向一个指针，后者指向线程的返回值。 （4）返回值：成功返回0；失败返回错误码 线程终止状态 调用pthread_join函数的线程将挂
Linux_深究多线程_(线程等待,线程终止,线程分离,线程互斥,可重入,线程安全）
代码铺子
04-24 789
1. 主 / 新线程2.线程等待3.线程终止4.部分总结5.线程分离6.线程分离总结7.线程互斥8. 互斥量总结9. 可重入 & 线程安全
Linux系统编程（17）——线程控制-结束线程、等待线程、线程分离
陌上人如玉，公子世无双。
05-30 598
结束线程 1.让线程的入口函数结束执行------最常见最主要使用的结束方式 2.pthread_exit：让本线程结束------但是很少使用它，它的参数是 void* 表示线程结束的返回结果（很少用到）；如果exit 全部线程都没了，这个不能混淆了。exit 结束进程。 void* ThreadEntry(void* arg) { //新线程入口，参数 (void)arg; ...
Linux：结束线程的三种方式
weixin_30267785的博客
04-05 1734
一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_joi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值