创建新线程导致异常

Question

我有一个计时器，它将创建一个新线程并在调用通知函数之前等待计时器到期。它在第一次执行期间可以正常工作，但是当第二次启动计时器时，会抛出异常以尝试创建新线程。 调试输出显示前一个线程在尝试创建新线程之前已经退出。

Timer.hpp：

 class TestTimer
{
private:
    std::atomic<bool> active;
    int timer_duration;
    std::thread thread;
    std::mutex mtx;
    std::condition_variable cv;
    void timer_func();
public:
    TestTimer() : active(false) {};
    ~TestTimer() {
        Stop();
    }
    TestTimer(const TestTimer&) = delete;               /* Remove the copy constructor */
    TestTimer(TestTimer&&) = delete;                    /* Remove the move constructor */
    TestTimer& operator=(const TestTimer&) & = delete;  /* Remove the copy assignment operator */
    TestTimer& operator=(TestTimer&&) & = delete;       /* Remove the move assignment operator */
    bool IsActive();
    void StartOnce(int TimerDurationInMS);
    void Stop();

    virtual void Notify() = 0;
};

Timer.cpp：

void TestTimer::timer_func()
{
    auto expire_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(timer_duration);
    std::unique_lock<std::mutex> lock{ mtx };
    while (active.load())
    {
        if (cv.wait_until(lock, expire_time) == std::cv_status::timeout)
        {
            lock.unlock();
            Notify();
            Stop();
            lock.lock();
        }
    }
}

bool TestTimer::IsActive()
{
    return active.load();
}

void TestTimer::StartOnce(int TimerDurationInMS)
{
    if (!active.load())
    {
        if (thread.joinable())
        {
            thread.join();
        }
        timer_duration = TimerDurationInMS;
        active.store(true);
        thread = std::thread(&TestTimer::timer_func, this);
    }
    else
    {
        Stop();
        StartOnce(TimerDurationInMS);
    }
}

void TestTimer::Stop()
{
    if (active.load())
    {
        std::lock_guard<std::mutex> _{ mtx };
        active.store(false);
        cv.notify_one();
    }
}

我的代码块在这里抛出了错误： thread = std::thread(&TestTimer::timer_func, this); 在第二次执行期间。

具体来说，错误是从 move_thread 函数抛出的：_Thr = _Other._Thr;

thread& _Move_thread(thread& _Other)
        {   // move from _Other
        if (joinable())
            _XSTD terminate();
        _Thr = _Other._Thr;
        _Thr_set_null(_Other._Thr);
        return (*this);
        }

    _Thrd_t _Thr;
    }; 

这是个例外：Unhandled exception at 0x76ED550B (ucrtbase.dll) in Sandbox.exe: Fatal program exit requested.

堆栈跟踪：

thread::move_thread(std::thread &_Other)
thread::operator=(std::thread &&_Other)
TestTimer::StartOnce(int TimerDurationInMS)

Answer 1

如果只是测试

1. 在调用析构函数时确保线程处理程序is empty or joined。
2. 使可以从多线程访问的所有内容线程安全（特别是读取active 标志）。只需将其设为 std::atomic_flag 即可。

您似乎正在杀死一个指向活动线程的线程句柄，但如果不查看整个应用程序就很难说。

如果不是测试

...然后，通常，当需要一个计时器时，无论是否重复，您都可以将alarm() 信号安排到自身中。您仍然是完全单线程的，甚至不需要与 pthread 库链接。示例here。

并且当期望需要更多计时器并保持一段时间时，值得将boost::asio::io_service（或asio::io_service，如果您需要无增强标头版本）的实例放入您已经成熟的应用程序中生产就绪的计时器支持。示例here。

Answer 2

您创建TestTimer 并第一次通过TestTimer::StartOnce 运行它，在那里您创建一个线程（在该行，稍后会引发异常）。当线程完成时，它会将active = false; 设置为timer_func。
然后你第二次拨打TestTimer::StartOnce。由于active == false，Stop() 不会在当前线程上调用，您继续在thread = std::thread(&TestTimer::timer_func, this); 中创建一个新线程。

然后是大但是：
在创建第二个线程之前，您还没有加入第一个线程。这就是它抛出异常的原因。