Question

我有一个可重用的类，它启动了一个无限的线程。只能通过调用设置kill switch变量的stop函数来杀死此线程。环顾四周时，对于volatile和原子变量存在相当多的争论。

以下是我的代码： program.cpp

int main()
{
ThreadClass threadClass;
    threadClass.Start();
    Sleep(1000);
    threadClass.Stop();
    Sleep(50);
    threaClass.Stop();
}

ThreadClass.h

#pragma once
#include <atomic>
#include <thread>

class::ThreadClass
{
public:
    ThreadClass(void);
    ~ThreadClass(void);
    void Start();
    void Stop();
private:
void myThread();
    std::atomic<bool> runThread;
    std::thread theThread;
};

ThreadClass.cpp

#include "ThreadClass.h"
    ThreadClass::ThreadClass(void)
    {
        runThread = false;
    }

    ThreadClass::~ThreadClass(void)
    {
    }

    void ThreadClass::Start()
    {
        runThread = true;
        the_thread = std::thread(&mythread, this);
    }

    void ThreadClass::Stop()
    {
        if(runThread)
        {
            runThread = false;
            if (the_thread.joinable())
            {
                the_thread.join();
            }
        }
    }

    void ThreadClass::mythread()
    {
        while(runThread)
        {
            //dostuff
            Sleep(100);  //or chrono
        }
    }

我在此处代表的代码反映了我们的遗留代码所具有的问题。我们调用stop函数2次，这将尝试加入线程2次。这会导致无效的句柄异常。我编写了Stop（）函数以解决该问题，但我的问题是，如果线程已经完成并加入，为什么第二次连接会失败？在尝试加入之前，是否有更好的方法可以假设线程有效？

正确结束无限的std :: thread

0 个答案: