thread::detach（）在C 11中是如何工作的？

Question

我编写了以下代码，但无法理解为什么它不能像在main（）线程中那样打印出threadFunc（）中的所有no（即0到-99）。

#include<iostream>
#include<thread>
#include<string>
#include<mutex>
#include<chrono>

using namespace std;

mutex mu;

void threadFunc(){
    for(int i=0;i>-100;i--){
    std::this_thread::sleep_for(std::chrono::milliseconds(30)); /*delay for 30ms*/
    mu.lock();
    cout<<"Thread:  "<<i<<endl;
    mu.unlock();
    }
}

main(){

    thread t1(threadFunc);   


    for(int i=0;i<100;i++){
    mu.lock();
    cout<<"Main:  "<<i<<endl;
    mu.unlock();    
    }


    cout<<"End of Main"<<endl;  

    t1.detach();   
}

程序的输出为：

Main: 0  
Main: 1  
.  
.  
.  
Main: 99  
End of Main.  
Thread: -1 

Answer 1

detach函数防止在线程对象超出范围时引发异常。通常，您希望调用join，但如果不想阻止执行，则需要调用detach。但是，如果main准备退出时线程仍在运行，则可能需要使用另一种同步机制来确保一切正常。请参见下面的人为示例。

#include <atomic>
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <string>
#include <thread>

std::mutex mu;
std::condition_variable cv;
bool finished = false;

void threadFunc()
{
    for (int i = 0; i < 5; ++i)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        std::unique_lock<std::mutex> lock(mu);
        std:: cout << "Thread:  " << (0 - i) << "\n";
    }

    std::unique_lock<std::mutex> lock(mu);
    finished = true;
    cv.notify_one();
}

int main()
{
    {
        std::thread t1(threadFunc);
        t1.detach(); // Call `detach` to prevent blocking this thread

    } // Need to call `join` or `detach` before `thread` goes out of scope

    for (int i = 0; i < 5; ++i)
    {
        std::unique_lock<std::mutex> lock(mu);
        std::cout << "Main:  " << i << "\n";
    }

    std::cout << "End of Main\n";

    std::unique_lock<std::mutex> lock(mu);
    cv.wait(lock, [&finished]() { return finished; });

    return 0;
}

Main:  0
Main:  1
Main:  2
Main:  3
Main:  4
End of Main
Thread:  0
Thread:  -1
Thread:  -2
Thread:  -3
Thread:  -4

现场实例

同样，上面是一个人为的示例，在您的情况下，在允许main返回之前，您可以更轻松地使用join而不是detach。

Answer 2

当main（）退出时进程终止，所有线程都被杀死。您在程序中观察到这种行为。

Detach基本上说，从现在开始，您不能加入这个线程。但是如果你不能加入它，你就不能让你的main（）等待它完成（除非你使用其他的同步原语），这样它就可以愉快地退出了。

这就是为什么我强烈反对每个人使用分离的线程，它们很难正确地完成。