线程的连接与分离

已于 2024-03-10 17:22:49 修改
阅读量444 收藏 5
点赞数 5
分类专栏： Linux系统编程 文章标签： linux
于 2024-02-01 13:52:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52484093/article/details/135957973
版权

再论线程返回值

int pthread_join(pthread_t thread, void** retval);

  • 等待的线程未退出，则调用线程陷入阻塞状态
  • 等待的线程已退出，则调用线程将获得线程返回值

pthread_join() VS wait()

进程之间的等待只能是父进程等待子进程

线程之间都可以进行 等待 / 连接

wait() 等待任意子进程退出，pthread_join 必须指定目标线程

pthread_join() 等待的线程必然是 pthread_create() 创建的线程

下面的程序输出什么？为什么？

多个线程同时 join 一个线程实验

test-1.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <sys/syscall.h>

pid_t gettid(void)
{
    return syscall(SYS_gettid);
}

void* thread_entry(void* arg)
{ 
    pid_t pt = gettid();
    
    int i = 0;
    int n = (long long)arg;
    
    for(i=0; i<n; i++)
    {
        printf("thread(%d): i = %d\n", pt, i);
        sleep(1);
    }
    
    return (void*)pt;
}

void* wait_entry(void* arg)
{ 
    pid_t pt = gettid();
    pthread_t t = (pthread_t)arg;
    int r = 0;
    
    sleep(1);
    
	printf("tid = %d\n", pt);
	
    r = pthread_join(t, NULL);
    
    printf("thread(%d) r = %d\n", pt, r);
    
    return NULL;
}

int main()
{
    int r = 0;
    void* tr = NULL;
    
    pthread_t t = 0;
    pthread_t wt = 0;
    
    printf("main(%d)\n", getpid());
    
    pthread_create(&t, NULL, thread_entry, (void*)5);
    pthread_create(&wt, NULL, wait_entry, (void*)t);
    pthread_create(&wt, NULL, wait_entry, (void*)t);
    
    while(1)
    {
        sleep(6);
    }
    
    return 0;
}

该示例中创建了 3 个线程，其中有 2 个线程会同时 join 另一个相同的线程

程序运行结果如下图所示：

通过打印可以看出，tid 为 19585 的线程 join 另一个线程成功了，而 tid 为 19584 的线程卡死在 pthread_join() 接口，一直无法返回

多个线程同时 join 另一个相同的线程，只能有一个线程 join 成功，其余的线程会卡死

注意

多个线程同时 join 到同一个线程时，行为是未定义的！

再论 wait() / waitpid() 的意义

子进程 退出 / 终止 后，部分系统资源会暂留 (为父进程提供重要信息)

父进程调用 wait() / waitpid()，为子进程 "收尸" 处理并释放暂留资源

如果子进程得不到回收，那么可能影响正常进程的创建 (系统资源无法释放)

思考

子线程结束执行，是否意味着系统资源被释放？

下面程序中变量 r 的值输出什么？为什么？

线程资源回收实验

test-2.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <sys/syscall.h>

pid_t gettid(void)
{
    return syscall(SYS_gettid);
}

void* thread_entry(void* arg)
{ 
    pid_t pt = gettid();
    
    int i = 0;
    int n = (long long)arg;
    
    for(i=0; i<n; i++)
    {
        printf("thread(%d): i = %d, &i = %p\n", pt, i, &i);
        sleep(1);
    }
    
    return (void*)(long)pt;
}

int main()
{
    int r = 0;
    void* tr = NULL;
    
    pthread_t t = 0;
    pthread_t wt = 0;
    
    printf("main(%d)\n", getpid());
    
    pthread_create(&t, NULL, thread_entry, (void*)5);
    
    sleep(6);
    
    // r = pthread_join(t, &tr);
    
    pthread_create(&t, NULL, thread_entry, (void*)5);
    
    printf("r = %d, tr = %ld\n", r, (long)tr);
    
    sleep(10);
    
    return 0;
}

该程序会先创建一个线程去执行 pthread_entry()，然后等这个线程执行结束后，再次创建一个线程去执行 pthread_entry()

pthread_entry() 会去打印线程栈中 i 的值和地址

程序运行结果如下图所示：

两个线程打印出来 i 的地址是不同的

将第 44 行的 pthread_join() 注释打开，查看运行结果

两个线程打印出来 i 的地址是相同的，说明了 pthread_join() 除了阻塞等待线程结束、获取线程结束返回值，还会释放线程所占用的资源

第 44 行，通过 pthread_join()，成功释放了第一个线程所占用的系统资源，创建出来的第二个线程直接复用了第一个线程所使用的线程栈，所以打印出来 i 的地址是相同的；如果不调用 pthread_join()，那么线程所占用的资源会得不到清理

实验结论

默认情况下，Linux 线程退出后不会主动释放系统资源

pthread_join() 除了等待线程执行结束，还会释放线程所占用的资源

当创建的线程过多且没有等待操作，可能造成系统资源严重泄漏

任意线程均可释放其它已经退出线程的系统资源

线程的分离

默认情况下，新创建的线程处于可连接状态 (Joinable)

可连接的线程退出后需要执行连接操作，否则线程资源无法释放

实际需求：

  • 线程不需要返回值，那么退出后就不应该需要连接
  • 线程退出则自动释放资源，不需要连接操作

不可连接线程 (分离线程)

在创建线程时，通过属性参数指定线程为 "分离状态"

  • int pthread_attr_setdetachstate(pthread_attr_t* attr, int detachstate);
  • int pthread_attr_getdetachstate(const pthread_attr_t* attr, int* detachstate);

通过 pthread_detach() 函数设置线程为 "分离状态"

  • int pthread_detach(pthread_t thread);

下面的程序是否会有内存泄漏？

线程分离实验

test-3.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <sys/syscall.h>

pid_t gettid(void)
{
    return syscall(SYS_gettid);
}

void* thread_entry(void* arg)
{ 
    pid_t pt = gettid();
    
    int i = 0;
    int n = (long long)arg;
    
    for(i=0; i<n; i++)
    {
        printf("thread(%d): i = %d, &i = %p\n", pt, i, &i);
        sleep(1);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}


int main()
{
    int r = 0;
    pthread_t t = 0;
    
    printf("main(%d)\n", getpid());
    
    pthread_create(&t, NULL, thread_entry, (void*)5);
    
    sleep(10);
    
    r = pthread_join(t, NULL);
    
    printf("r = %d\n", r);
    
    return 0;
}

主线程创建了一个线程去执行 pthread_entry()，然后休眠 10s 后，去连接这个创建出来的线程

pthread_entry() 中通过 pthread_detach() 将自身设置为分离线程

程序运行结果如下图所示：

通过打印可以看出，无法去连接一个分离状态的线程

test4.c

#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <sys/syscall.h>

pid_t gettid(void)
{
    return syscall(SYS_gettid);
}

void* thread_entry(void* arg)
{ 
    pid_t pt = gettid();
    
    int i = 0;
    int n = (long long)arg;
    
    for(i=0; i<n; i++)
    {
        printf("thread(%d): i = %d, &i = %p\n", pt, i, &i);
        sleep(1);
    }
    
    pthread_detach(pthread_self());
    
    return NULL;
}


int main()
{
    pthread_t t = 0;
    
    printf("main(%d)\n", getpid());
    
    pthread_create(&t, NULL, thread_entry, (void*)5);
    
    sleep(6);
    
    pthread_create(&t, NULL, thread_entry, (void*)5);
    
    sleep(6);
    
    return 0;
}

主线程创建了两个线程，第二个线程等第一个线程运行结束后再创建出来

程序运行结果如下图所示：

两个子线程打印出来 i 的地址是相同的，说明线程设置为分离状态后，会在运行结束后释放线程资源，第二个线程的线程栈直接复用了第一个线程的线程栈

实验结论

线程进入分离状态，其它线程无法连接 (不可等待 且 无法获取返回值)

分离状态的线程退出后主动释放系统资源 (常规需求)

线程的分离状态指线程不可能执行连接操作 (并非脱离进程不可控)

在工程开发中，一定要做好线程设计 (线程间是否需要等待？)

qq_52484093
关注
专栏目录
数据库连接，线程，ThreadLocal三者之间的关系
m0_71777195的博客
03-30 487
该线程在进行数据持久化时需要申请数据库连接，当做完之后就将连接释放回线程池，但之后进行数据库切换时也需要数据库连接，这时候继续申请吗？不是的，这时ThreadLocal就派上用场了，在第一次数据持久化操作做完之后，将这个数据库连接暂存在ThreadLocal中，在之后的数据库切换中需要用到时再拿出来用。举个例子，一个线程的生命周期要做这么几件事情：参数校验，业务逻辑1，数据持久化，业务逻辑2，数据库切换，业务逻辑3。我们知道，数据库连接是很宝贵的资源，以MySQL为例，一台MySQL服务器。
线程的连接和分离
L_smartworld的博客
02-06 664
概述 线程的分离属性(detach属性):资源释放操作。在线程结束后，由系统释放资源 线程的连接属性(join属性):资源释放操作。由一个线程监督该执行线程，结束后释放资源 线程创建的默认属性为joinable 线程属性操作 在Linux平台默认情况下，虽然各个线程之间是相互独立的，一个线程的终止不会去通知或影响其他的线程。但是我们需要关心线程终止的状态以及释放线程所占的资源: 已经终止的...
线程的分离链接属性
weixin_30753873的博客
07-03 148
概述 线程的分离属性和连接属性分别对应线程结束后，资源释放的操作.join属性的线程，需要同一个进程中的其他线程，获取线程终止的状态，并释放资源．detach属性的线程，在线程结束后，由系统释放资源．线程创建的默认属性为joinable 线程属性操作 在Linux平台默认情况下，虽然各个线程之间是相互独立的，一个线程的终止不会去通知或影响其他的线程。但是我们需要关心线程终止的状态以及释放线程...
(6)线程的连接和分离
qq_38813056的博客
12-28 959
①线程连接     [1]int pthread_join(pthread_t thread, void **retval);     pthread_t:  等待的线程尚未退出，那么 pthread_join 的调用线程就会陷入阻塞。     retval:     接收返回值         · 等待的线程尚未退出，那么pthread_join 的调用线程就会陷入阻塞。         · 等...
Linux多线程学习（二）线程的连接与分离
玄天693
04-22 662
一、线程的连接与分离 线程分为分离线程和非分离线程，分离线程退出时会释放它的资源，非分离线程退出时，不会释放资源，需要另一个线程为它调用pthread_join函数或者进程退出时才会释放资源，只有非分离线程才是可连接的，线程一旦设置为PTHREAD_CREATE_DETACH状态（不论是创建时设置还是运行时设置）则不能再恢复到PTHREAD_CREATE_JOINABLE状态。 ...
C++多线程的创建、终止.、连接和分离线程等pdf
最新发布
05-15
本文介绍了C++中多线程的基础概念以及如何使用POSIX线程库和C++11标准库创建、终止、连接和分离线程。多线程编程能够显著提高程序的性能和响应速度，但同时也需要注意线程安全性和同步问题。对于初学者而言，建议从...
python GUI库图形界面开发之PyQt5 UI主线程与耗时线程分离详细方法实例
09-17
### Python GUI库图形界面开发之PyQt5 UI主线程与耗时线程分离详细方法实例 #### 背景介绍 在进行GUI程序设计时，一个重要的原则是将用户界面(UI)的操作与其他耗时任务（如网络请求、数据库操作、大量计算等）分离...
多线程3——线程连接、分离和取消（linux）
Jerry的博客
07-25 216
多线程3——线程连接、分离和取消（linux）
QT/C++ TCP多线程客户端（收发线程分离，自动粘包处理，自动数据包成型）
09-03
因此，通过使用多线程，我们可以将接收和发送操作分离开，以提高系统的并行处理能力。 1. **多线程模型**：在本项目中，采用了两种线程来处理不同的任务——一个用于接收数据，另一个用于发送数据。这种设计可以...
【Linux C | 多线程编程】线程的连接、分离，资源销毁情况
wkd_007的博客
04-01 2150
本文结束了Linux系统编程的线程的连接(pthread_join)、线程的分离(pthread_detach)，以及介绍了为什么要使用线程的连接、分离。
C ++ 11多线程–第2部分：连接和分离线程
qq_43690118的博客
08-30 384
翻译来自：C++11 Multithreading – Part 2: Joining and Detaching Threads 在本文中，我们将讨论std :: thread的连接和分离。 用std :: thread :: join（）连接线程 一旦启动一个线程，则另一个线程可以等待该新线程完成。为此，还需要在std :: thread对象上调用join（）函数，即 std::thread th(funcPtr); // Some Code th.join(); 让我们来看一个例子 假设主线程必须启
【C++并发编程】（二）线程的创建、分离和连接
weixin_44378835的博客
05-03 989
在C++中，线程的分离（detach）和连接（join）是用于管理线程生命周期的两种主要方式。当创建一个线程时，你可以选择让它独立运行（即分离），或者等待它完成执行（即连接）。方法时，你告诉线程库你不再关心这个线程的结束时间，并且你不需要获取它的返回值。线程将在后台独立运行，直到其函数返回，结束。当你想在线程中执行某个有参数或无参数的函数时，你可以将该函数传递给。方法时，你告诉线程库你想要等待这个线程完成执行后再继续下去。你还可以传递类的成员函数和类的实例给线程。的线程将被阻塞，直到被连接的线程执行完毕。
线程的分离、同步
sweet_orange8的专栏
02-19 1321
有关线程分离->在任何一个时间点上，线程是可结合的（joinable）或者是分离的（detached）。 ->一个可结合的线程能够被其他线程回收其资源和杀死。在被其他线程回收之前，它的存储器资源（栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或者杀死的，它的存储器资源在它终止时由系统自动释放 ->默认情况下，线程被创建程可结合的。为了避免存储器泄露，每个可结合线程，要么不饿显示的回收，
线程的分离与结合
dong18292000671的博客
06-15 785
线程是可结合或分离的。一个可结合的线程能够被其他线程收回资源和杀死。相反，一个分离的线程是不能被其他线程收回或杀死的，它的存储器资源在它终止时由系统自动释放。 默认情况下，线程被创建为可结合的。 线程分离函数：int pthread_detach(pthread_t thread); 由于调用pthread_join后，如果该线程没有运行结束，调用者会被阻塞，但有些情况并不希望如此，所以可以在
线程连接
牧羊女
07-11 1138
线程可分为两种，一种是可连接的(joinable)，另一种是不可连接的(unjoinable)，也就是分离的(detached)。 在Linux下，通过pthread_create()创建的线程默认是可连接的，当线程退出时，系统不会去释放该线程的资源。这时，需要pthread_join()去获取该线程的状态，并释放其占用的资源。如果一个可连接的线程在退出后不被连接，将会产生僵尸线程(zombie...
线程的分离状态与结合状态
weixin_30634661的博客
12-05 125
　　以下内容引用自：http://www.cnblogs.com/mydomain/archive/2011/08/14/2138454.html 在任何一个时间点上，线程是可结合的(joinable)，或者是分离的(detached). 可结合的线程能够被其他线程收回其资源和杀死；在被其他线程回收之前，它的存储器资源（如栈）是不释放的。 分离的线程是不能被其他线程回收或者杀死的...
连接线程Join()方法
stevenjin的专栏
05-23 1520
Join()方法会暂停给定的线程。连接两个线程的意思就是调用Join()方法时，运行着的线程将进入WaitSleepJoin状态，而直到调用Join()方法的线程完成了任务，该线程才会返回到Running状态。using System;using System.Threading;namespace thread...{    public class JoiningThread    .
连接线程与等待一个对象
10-04 633
连接线程      一个线程需要另一个线程的结果是很常见的。Java提供了三个join( )方法，允许一个线程在继续执行前等待另一个线程结束。这些方法如下      public final void join() throws InterruptedException      public final void join(long milliseconds) thro
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值