解析进程中的detach ,join,thread;

关于进程解析。进程的解释:一段程序运行的过程被视为进程;

关于线程的解析。 线程的解释: 每一个进程的时段中都有一个线程,主线程。可以分配多个子线程。

关于并发的解析。并发的解析:多个进程的同时进行这个点叫做并发;


 #include <iostream>
#include <thread>



void myprintf_tow() {
    for (int i = 1; i < 10; i++) {
        std::cout << " detach的数据 " << i << std::endl;
    }
    return;
}
void myprintf() {
    std::cout << "i am chning 1" << std::endl;
    ///...
    std::cout << "ia am chinf 3" << std::endl;
    return;
 }
int main()
{
    std::thread mytobj(myprintf);
    mytobj.join();
    std::cout << "she an chian " << std::endl;
   // std::thread mytobj2;
    std::thread mytobj2(myprintf_tow);
     
    mytobj2.detach();
    std::cout << "detach 将结束运行" << std::endl;

    std::cout << "结束时间段的运行" << std::endl;
   // std::cout << "Hello World!\n";
}

join ()的解析——————

 加入+汇合的意思的含义。与thread形成的是传统的程序构造;子线程与主线程都会执行,顺序不一定会一样,但是结果一定一样,因为主线程会被Join()进行阻塞;拦截下来,等都运行结束才会放过主线程;

detach()的解析————

 在传统上的个例外。由于某一些线程我们不用等他们。就可以进行使用;但是极度危险,很有可能卉丢失数据;

比如上面的小例子;后台执行子线程,主线程已经结束; detach()通长会失去控制 ;

 一旦用了detach 过后我们就会失去对于线程的控制,所以再用join 就会有bug ;

对于joinable()---------;

 用来判断 是否能够Join()的函数;

 thread mytobj(myprintf); 

  if(mytobj.joinable()){
     mytobj.join();

}

关于类的引用

#include <iostream>
#include <thread>


class TA {
public : 
    int& m_i;
    TA(int& i) :m_i(i) {
        //
     }
    void operator()() {
        std::cout << "m_i3的值是" << m_i << std::endl;
        std::cout << "m_i的4值是" << m_i << std::endl;
        std::cout << "m_i的值5是" << m_i << std::endl;
        std::cout << "m_i的值是6" << m_i << std::endl;
     }

};
int main() {
    int m_Y = 6;
    TA ta(m_Y);
    std::thread myobj(ta);
    myobj.join();
    std::cout << "我想要的数据结束" << std::endl;
    return 0;





}c

关于operator()() 含义我也不清楚;

 解释一下。

创建一个类的名将TA‘ 后我们拎一个对象叫ta ;在类中做一个引用;使得主线程结束的M_y 能够进入TA的内置中;

 然后我们将实验个m_Y的值;

 如果我们能将join() 变化为一个detach的话我们就可以分析出来这个ta 是复制进去的; 很影响m_i的值;

可以加一个析构函数;

 这样我们就可以分析出来;

 auto mylamthread = [] {
        std::cout << "我将灰来" << std::endl;
        std::cout << "我将灰来" << std::endl;
        std::cout << "我将灰来" << std::endl;
        std::cout << "我将灰来" << std::endl;
    };
    std::thread mytobj3(mylamthread);
    mytobj3.join();
    std::cout << "tirn" << std::endl;

 这个也可以去试一下;

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
thread joindetach是线程管理的两种方式。 thread join用于等待线程执行完成。当调用join方法时,主线程会被阻塞,直到被调用的线程执行完毕。这样可以确保主线程在子线程执行完成后再继续执行。 示例代码如下: ```cpp #include <iostream> #include <thread> void myFunction() { // 线程执行的代码 std::cout << "子线程执行完毕" << std::endl; } int main() { std::thread t(myFunction); // 创建子线程 t.join(); // 等待子线程执行完成 std::cout << "主线程继续执行" << std::endl; return 0; } ``` 运行结果: ``` 子线程执行完毕 主线程继续执行 ``` thread detach用于将线程与主线程分离。分离后的线程将会独立运行,主线程不会再对其进行管理。一旦调用detach方法,主线程就不再关心该线程的状态,也不能再通过join方法等待其执行完成。 示例代码如下: ```cpp #include <iostream> #include <thread> void myFunction() { // 线程执行的代码 std::cout << "子线程执行" << std::endl; } int main() { std::thread t(myFunction); // 创建子线程 t.detach(); // 分离子线程 std::cout << "主线程继续执行" << std::endl; return 0; } ``` 运行结果: ``` 主线程继续执行 子线程执行(可能在主线程结束前打印,也可能在主线程结束后打印) ``` 需要注意的是,一旦线程被分离,其生命周期将独立于主线程,无法再对其进行操作或控制。因此,在使用detach前必须确保子线程能够正常完成执行。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

老鬼城

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

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

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

打赏作者

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

抵扣说明:

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

余额充值