joinable()：判断是否可以成功使用join()或者detach()学习笔记

最新推荐文章于 2024-07-07 14:21:27 发布
原创 最新推荐文章于 2024-07-07 14:21:27 发布 · 1.2k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细解析了C++中线程类的joinable()方法,该方法用于判断线程是否可以被join()或detach().通过示例代码展示了如何使用joinable()检查线程状态。

joinable()：判断是否可以成功使用join()或者detach(),返回true表示可以使用join()或者detach()
返回fasle表示不可以

void fun_th()

{

    cout<<"线程执行"<<endl;

}

 


thread myth(fun_th);
if(myth.joinable())
{
    cout<<"joinable() == true"<<endl;

}else{
    cout<<"joinable() == fasle"<<endl;
}

myth.datach();

if(myth.joinable())
{
    cout<<"joinable() == true"<<endl;

}else{
    cout<<"joinable() == fasle"<<endl;
}

45 C++11 多线程 ------ 线程启动，结束，创建线程方法，join()，detach()，joinable()方法，类的成员函数来作为 线程的入口函数。
hunandede的博客
01-11 706
前面的内容知道，程序运行起来，生成一个进程，该进程所属的主线程从main方法开始自动运行直到return 结束。我们创建一个线程，也要从一个函数开始运行，一旦这个函数运行起来，就代表着我们这个线程开始运行，一旦这个函数运行结束，就代表着这个线程运行结束。C++11提供了thread 这个类，因此第一步就是要 #include 使用 thread 类 ，构建对象的时候，传递的参数是一个方法，我们这里 是：mythreadmethod().暂时没有传递参数。
《Effective Modern C++》学习笔记 - Item 38: 注意future析构函数的不同行为
アルタイル
04-01 1492
std::thread 和非延迟的 std::future 内部都对应着一个实际的线程，可以认为这些对象是我们对系统线程的 handle。 从这个角度来看，std::thread 和 future 在析构函数中有不同的行为是比较奇怪的：如 Item 37 所述，销毁一个 joinable 的 std::thread 会导致程序终止；然而销毁 future 有时会表现地如隐式执行了 join，有时如隐式执行了 detach，有时二者皆非，但无论如何都不会导致程序终止。本节中，我们就对 future 的..
2.joinable()函数
weixin_41441169的博客
01-04 682
因为相同的线程不能join两次，也不能join完再detach或反过来，所以joinable函数就是用来判断当前这个线程是否可以join/detach的。joinable()函数是一个布尔类型的函数，他会返回一个布尔值来表示当前的线程是否是可执行线程(能被join或者detach)。
C++11多线程中的detach()、join()、joinable()
KingOfMyHeart的博客
07-19 7323
一.传统多线程编写: 一般来说,我们在主线程中开辟出一些子线程来完成我们的任务,正常情况下,需要在主线程的最后调用join(),用于阻塞主线程,避免主线程先于其他子线程执行完毕,退出,然后导致整个进程的异常. join():阻塞主线程,等待其他子线程执行完毕,正常退出. 二.非传统多线程编写: 引入detach() 有人说,我们创建多个线程完成一些任务,不过需要主线程最后等待所有的子线程完毕才能...
C++多线程编程：其二、join()和joinable()函数
jiexianxiaogege的博客
11-06 1273
一、join的功能
pthreads之joinable和detach函数
creator123123的博客
03-12 304
&#13; Joinable and Detached Threads http://www.domaigne.com/blog/computing/joinable-and-detached-threads/ Introduction By default, created threads are joinable. That means, we can wait for ...
C++ 并发编程实战 学习笔记
myc13381的博客
07-07 1599
C++ 并发编程实战学习记录
日常记录学习，基础知识，学习笔记
09-24
在创建线程时可以通过`pthread_create()`函数的参数设定线程状态，或者在线程运行中使用`pthread_detach()`将其变为UNJOINABLE状态。`pthread_detach(pthread_self())`可以在子线程内部调用，使子线程自我分离，结束...
多线程学习笔记，关于创建线程，删除线程等相关指令的应用。
09-14
- **Unjoinable状态**：通过`pthread_detach`函数，线程可以从joinable状态转换为unjoinable状态。一旦线程变为unjoinable，它在结束时会自动释放资源。 2. **pthread_detach**： - **pthread_detach(pthread_...
Boost库学习笔记（3）—— Fiber
hezhanran的博客
12-07 5650
一、概述         Boost.Fiber是一种微线程（用户层），也可以叫作纤程（协程），与一般的协程相比，其内部提供了调度管理器。每个fiber都有自己的栈，它可以保存当前的执行状态，包括所有寄存器的CPU标志、指令指针和堆栈指针，然后可以从此状态恢复。其目的是在单个线程上通过协作调度运行多个可执行序列（即函数）。正在运行的fiber可以明确的决定什么时候yield，来允许另外一个fiber运行（上下文切换）。在x86上
C++中，std::thread 类型成员函数 joinable()
目前在做 ROS相关的工作，主要是写ROS相关和C++的学习心得
07-03 7393
在C++中，std::thread 类型有一个成员函数 joinable()，它用于检查一个线程是否可以加入（joinable）。一个可加入的线程是指一个线程已经启动，并且还没有被加入或分离。joinable() 函数返回一个布尔值，如果线程可以加入，则返回 true，否则返回 false。当一个线程被加入后，它的执行将会被阻塞，直到其他线程调用 join() 函数将其加入。
C++11多线程，线程对象（thread对象）joinable()、join()、detach()、左值、智能指针
Dontla的博客
11-04 4034
C++线程库通过构造一个线程对象来启动一个线程，该线程对象中就包含了线程运行时的上下文环境，比如：线程函数、线程栈、线程起始状态等以及线程ID等，所有操作全部封装在一起，最后在底层统一传递给_beginthreadex() 创建线程函数来实现 (注意：_beginthreadex是windows中创建线程的底层c函数)。创建一个线程，默认状态是joinable状态，需要主线程等待，如果不希望去等待退出的线程，需要在线程退出之前使用线程对象的成员函数detach来线程分离。貌似不会报错，没啥影响。
线程函数join、detach、joinable
qq_45611002的博客
08-11 1446
1、join()函数，是一个等待线程完成函数，主线程需要等待子线程运行结束了才可以结束。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。 2、detach()函数，称为分离线程函数，使用detach()函数会让线程在后台运行，即说明主线程不会等待子线程运行结束才结束。 3、joinable()函数，是一个布尔类型的函数，它会返回一个布尔值来表示当前的线程是否可执行线程（能被join或者detach）。 ...
c++ thread的join和joinable的区别
weixin_39291964的博客
03-14 1803
在C++中，类提供了对线程的操作和管理。理解join()方法和joinable()方法之间的区别对于正确使用多线程至关重要。
C++多线程：线程的创建、join、detach、joinable方法（二）
weixin_43808717的博客
03-29 3316
线程的创建方式也可以通过传入一个类对象，并在类内部对函数运算符()进行重载，使用detach或者join都行。public:std::cout
多线程C++实现（1）之我的第一个多线程程序（join()、detach()、joinable()）
请叫我少爷的博客
09-02 784
建立多线程的三种方法： 普通函数 类对象(2.1类中重载小括号（）运算符 ， 2.2普通的成员函数) lambda 上代码： #include <iostream> #include <thread>//我们通过thread来建立多线程 using namespace std; void my_function() { cout << ...
C++多线程中的join, detach, joinable
热门推荐
Charles_Zaqdt的博客
02-01 1万+
thread是C++11中提供多线程编程的模块，使用的时候需要包含<thread>头文件。 首先我们先来看一下简单的hello world的多线程的代码(win10下vs2019) 这个创建的方式就是以函数作为一个入口，创建了一个子线程，那么创建的语句就是第11行代码所示，所传入的参数就是入口的函数名。在创建了这个子线程之后...
Linux中joinable（结合线程）消费者和生产者模型
xxxxxxxxxxxxxxx
03-18 414
** Linux中joinable和原子、互斥锁的操作 ** 注：线程默认是joinable（结合线程） 使用分文件编程思想，定义工厂头文件 “product.h” #include <stdio.h> #include <string.h> #include <stdlib.h> #include <pthread.h> #include <sys/types.h> #include <unistd.h> #include <s
std::thread detach() join() release() terminate()
最新发布
08-19
<think>我们讨论的是C++中std::thread的成员函数：detach(), join()，以及相关的release()和terminate()。 注意：std::thread没有release()成员函数，terminate()是C++异常处理中的函数，不是std::thread的成员。 因此，问题可能希望我们解释detach()和join()，并澄清release()和terminate()在C++多线程中的角色。 1. detach(): 允许线程独立执行，主线程不必等待它结束。分离后，原std::thread对象不再代表该线程，且无法再对该线程进行join或detach。 2. join(): 阻塞当前线程（通常是主线程或调用线程），直到被调用的线程执行完毕。调用join()后，线程对象变为不可连接（non-joinable），可以安全销毁。 3. release(): 注意，std::thread没有release()函数。这个名称可能与其他资源管理对象（如std::unique_ptr）混淆。在std::thread中，我们通过detach()或join()来释放线程资源的所有权，但线程对象本身需要被销毁或重新赋值。 4. terminate(): 这不是std::thread的成员函数。当异常没有被捕获，且到达main函数之外，或者当线程的析构函数被调用而线程仍可连接（joinable）时，会调用std::terminate()。它是C++标准库中的一个函数，用于终止程序执行。 下面详细解释： 一、detach() 和 join() 的使用 当我们创建一个线程对象并启动一个新线程后，必须在线程对象销毁前调用join()或detach()，否则在std::thread的析构函数中，如果线程仍然是可连接的（joinable），则会调用std::terminate()终止程序。 示例代码： ```cpp #include <iostream> #include <thread> void thread_function() { std::cout << "Thread function executing\n"; } int main() { std::thread t(thread_function); // 必须在t销毁前调用join或detach // 方法1：等待线程结束 // t.join(); // 方法2：分离线程，使其独立运行 t.detach(); // 注意：分离后，不能再对t进行join或detach，且t不再代表任何线程。 // 此时，主线程可以继续执行而不等待。 // 检查线程是否可连接 if (t.joinable()) { // 如果这里为真，说明还没有调用join或detach t.join(); // 或者t.detach(); } else { std::cout << "Thread is not joinable\n"; } return 0; } ``` 二、release() 函数？ 在C++11的std::thread中，并没有名为release()的成员函数。但是，我们可以通过移动语义来转移线程的所有权： ```cpp std::thread t1(thread_function); std::thread t2 = std::move(t1); // t1的所有权转移给t2，t1变为非线程对象 ``` 此时，t1不再代表任何线程，相当于“释放”了对原线程的所有权。但这不是通过release()成员函数实现的。 三、terminate() 函数 当出现以下情况时，会调用std::terminate()： - 当异常没有被捕获（即异常传播到main函数之外）。 - 当线程对象的析构函数被调用，而该线程仍然是可连接的（joinable）时。 因此，我们必须确保在std::thread对象销毁前，已经调用过join()或detach()。 错误示例： ```cpp void run() { std::thread t(thread_function); // 没有调用join或detach，t在函数结束时被销毁，此时线程仍可连接，导致std::terminate被调用。 } // 这里会调用t的析构函数，由于t是joinable的，程序终止。 ``` 四、总结 - detach(): 分离线程，线程独立运行，资源由运行时库自动回收。 - join(): 等待线程结束，回收线程资源。 - release(): 不存在，但可以通过移动操作转移线程所有权。 - terminate(): 当线程对象析构时仍可连接，会引发terminate。 因此，正确使用std::thread的关键是：在销毁线程对象前，确保已经调用了join()或detach()。 §§相关问题§§: 1. 在C++中，如何安全地传递std::thread对象的所有权？ 2. 当线程函数抛出异常时，在join()调用点会发生什么？如何处理？ 3. 分离线程（detached thread）在程序退出时会被强制终止吗？如何确保分离线程正常退出？ 4. 为什么在std::thread析构函数中，如果线程是可连接的（joinable），会调用std::terminate？</think>### 回答：`std::thread` 的 `detach()`, `join()`, `release()`, `terminate()` #### 1. `join()`：等待线程完成 **作用**：阻塞当前线程，直到被调用的线程执行完毕。 **使用场景**：需要获取线程执行结果或确保线程执行顺序时。 **关键点**： - 每个线程对象只能调用一次 `join()` - 调用后线程对象变为 *non-joinable* 状态 ```cpp #include <iostream> #include <thread> void task() { std::cout << "Task running\n"; } int main() { std::thread t(task); t.join(); // 主线程在此等待t完成 std::cout << "Thread completed\n"; } ``` #### 2. `detach()`：分离线程 **作用**：将线程与 `std::thread` 对象分离，允许线程独立运行。 **使用场景**：后台任务（如日志、监控），无需等待结果。 **关键点**： - 分离后无法再调用 `join()` - 分离线程的资源由运行时自动回收 ```cpp void daemon_task() { while (true) { // 后台任务逻辑... } } int main() { std::thread t(daemon_task); t.detach(); // 分离线程 // 主线程继续执行... } ``` #### 3. `release()`：⚠️ 不存在此成员函数 **常见误解**： - C++ 标准库 **没有** `std::thread::release()` 函数 - 可能与其他 API（如 `std::unique_ptr::release()`）混淆 #### 4. `terminate()`：线程异常终止 **作用**：当线程函数抛出未捕获异常时调用 `std::terminate()`。 **触发条件**： 1. 线程函数抛出异常且未被捕获 2. 线程对象析构时仍为 *joinable* 状态 ```cpp void risky_task() { throw std::runtime_error("Unexpected error"); } int main() { std::thread t(risky_task); // 未捕获异常将导致 std::terminate() t.join(); } ``` --- ### 关键行为总结 | 操作 | 调用前状态 | 调用后状态 | 是否阻塞 | 资源回收方式 | |---------------|-------------|-------------|----------|-------------------| | `join()` | joinable | non-joinable| 是 | 立即回收 | | `detach()` | joinable | non-joinable| 否 | 线程结束时自动回收 | | (析构未处理) | joinable | - | - | 调用 `terminate()` | --- ### 最佳实践与注意事项 1. **RAII 包装器**：使用 `std::jthread` (C++20) 自动处理生命周期 ```cpp // C++20 示例 std::jthread auto_join_thread([]{ // 任务逻辑 }); // 析构时自动 join ``` 2. **异常安全处理**： ```cpp std::thread t; try { t = std::thread([]{ /* 可能抛异常的任务 */ }); t.join(); } catch (...) { if (t.joinable()) t.join(); // 确保资源回收 } ``` 3. **状态检测**： ```cpp if (t.joinable()) { // 必须选择 join 或 detach t.detach(); } ``` 4. **禁止的操作**： ```cpp std::thread t1(task); std::thread t2 = t1; // 错误！不能复制线程对象 std::thread t3 = std::move(t1); // 正确：所有权转移 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

aFakeProgramer

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值