不调用 Thread.join() 时的 C++ 多线程异常

Question

我有一个非常简单的程序，它给了我一个我不理解的异常。我有一个用 Visual Studio Express 2012 for Desktop 编写的 C++ 应用程序。

我创建了一个多线程应用程序，其中有 2 个线程，一个调用一个人类，另一个调用另一个汽车类。

当我使用 thread.join() 时，我没有得到异常，但我没有得到所需的输出。当我注释掉 thread.join() 时，我得到了异常，但我也得到了所需的输出。

例外情况是： enter image description here

我只是想让两个线程同时执行和处理。人和汽车类都调用了一个方法，该方法在线程睡眠时重复 10 次，它所做的只是为人员类打印一个字符串“开始行走”，为汽车类打印一个字符串“开始驾驶”，而主线程只有“主要等待...”

所以程序的输出是：

started walking
started driving
started walking
started driving
main waiting...
started walking
started driving
started walking
started driving
main waiting...

等等。这就是我想要的。

如果我取消注释加入方法，我会得到以下输出：

started walking
started walking
(repeat 8 more times)
started driving 
started driving
(repeat 8 more times)
Main waiting..
Main waiting..
(repeat 8 more times)

这不是我想要的。

如果不使用 join() 方法，我怎样才能让这个应用程序在没有异常的情况下执行？

作为一个仅供参考，这是我在下面创建的示例代码：

这是启动程序的主要方法。

include <iostream>
#include <thread>
#include <chrono>
#include "person.h"
#include "car.h"

int count1 = 0;
int count2 = 0;

int main()
{
    person p1;
    thread t1(&person::startWalking, p1);
    if(t1.joinable())
    {
        //t1.join();
    }

    car c1;
    thread t2(&car::startDriving, c1);
    if(t2.joinable())
    {
        //t2.join();
    }

    for(int x = 0; x < 10; x++)
    {
        std::cout<<"Main waiting...\n";//<<std::endl;
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
    return 0;
}

这是 person.cpp 文件：

#include "person.h"
person::person(void)
{
}
person::~person(void)
{
}
void person::startWalking()
{
    for(int x = 0; x < 10; x++)
    {
        cout<<"Started Walking.\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

void person::stopWalking()
{
    cout<<"Stopped Walking.\n";
}

这是 car.cpp 文件：

#include "car.h"

using namespace std;

car::car(void)
{
}
car::~car(void)
{
}
void car::startDriving()
{
    for(int x = 0; x< 10; x++)
    {
        std::cout<<"started driving\n.";
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

Answer 1

首先，document 读取 If the thread is joinable when destroyed, terminate() is called.，所以如果你注释 thread.join() 并且 main 函数完成，线程必须调用析构函数，它会调用 terminate 和 @ 987654326@ 在这里是abort，所以你有一个例外！

如果你取消注释 thread.join(), join 方法 returns when the thread execution has completed. 所以你不能得到例外的答案。

建议：

移动

if(t1.joinable())
{
    t1.join();
}

和

if(t2.joinable())
{
    t2.join();
}

在std::this_thread::sleep_for(std::chrono::milliseconds(5000)); 之前。您可以看到这三个线程同时执行，但您也无法获得您想要的结果，因为t1 和t2 睡眠1 秒，所以主线程会很快打印Main waiting...。所以你应该在 t1 和 t2 中注释 sleep 或者在 main 的 for 中为每个循环添加相同的睡眠时间。

提示：这三个线程会竞争，输出缓冲区会随机填充，所以输出是不可预测的，你可以添加一个互斥体来保证输出可读。

这是我的参考代码：

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

std::mutex mMutex;

class person {
public:
    void startWalking()
    {
        for(int x = 0; x < 10; x++)
        {
            mMutex.lock();
            std::cout<< "Started Walking.\n";
            mMutex.unlock();
            //std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
    }
};

class car {
public:
    void startDriving()
    {
        for(int x = 0; x< 10; x++)
        {
            mMutex.lock();
            std::cout <<"Started driving.\n";
            mMutex.unlock();
            //std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
    }
};

int main()
{
    person p1;
    std::thread t1(&person::startWalking, p1);

    car c1;
    std::thread t2(&car::startDriving, c1);

    for(int x = 0; x < 10; x++)
    {
        mMutex.lock();
        std::cout <<"Main waiting...\n";
        mMutex.unlock();
        //std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
    t1.join();
    t2.join();
    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
    return 0;
}