std::thread 导致应用程序中止并出现错误 R6010

Posted 2023-02-22

【中文标题】std::thread 导致应用程序中止并出现错误 R6010

【英文标题】：std::thread causing application to abort with error R6010

【发布时间】：2014-01-28 19:55:23

【问题描述】：

我有一个名为 Task 的类，它在内部拥有一个成员 std::thread。总体思路是创建一个在处理请求到来时保持活动状态的线程。

class Task

public:
    Task();
    ~Task();

    void start();
    // some funny stuff here
protected:
    Task(const Task& ref);
    void main_function();

    std::thread m_thread;
    // more funny stuff like queues, mutexes, etc

在函数 start() 中我这样做：

void Task::start()

    m_thread = std::thread(std::bind(&Task::main_function, this));

问题是这一行调用 abort() 时出现运行时错误 R6010。我在某处读到，这可能是由于 m_thread 的析构函数在没有先前加入的情况下被调用，但由于线程尚未启动，我无法加入它。

我正在使用 Visual Studio 2012 运行它

更新：

所以我尝试了一个测试示例，但无法复制错误。然后我在有问题的函数中替换了我的 start 函数，如下所示：

void Task::start()

    assert(!m_thread.joinable());
    m_thread = std::thread(&Task::main_function,this);

但我仍然收到错误 R6010。 调用栈是：

msvcr110d.dll!_NMSG_WRITE(int rterrnum) Line 226    C
msvcr110d.dll!abort() Line 62   C
msvcr110d.dll!terminate() Line 97   C++
msvcp110d.dll!_Call_func(void * _Data) Line 63  C++

msvcr110d.dll!_callthreadstartex() Line 354 C
msvcr110d.dll!_threadstartex(void * ptd) Line 337   C

更新 2： 终于可以复制问题了。代码如下。在 main 函数中调用 foo()。

class Task 

public:
    Task() : m_exitFlag(false) 
     
        std::cout << "constructor called" << std::endl;
    

    ~Task()
    
        m_lock.lock();
        m_exitFlag = true;
        m_condlock.notify_all();
        m_lock.unlock();

        if (m_thread.joinable()) m_thread.join();
        std::cout << "destructor called" << std::endl;
     

     void start()
     
         std::cout << "Task start" << std::endl;
         assert(!m_thread.joinable());
         m_thread = std::thread(&Task::main_function, this);
     
protected:
     void main_function()
     
         std::cout << "thread started" << std::endl;
         while(1)
         
             m_lock.lock();
             while(m_queue.empty() && !m_exitFlag)
                 m_condlock.wait(std::unique_lock<std::mutex>(m_lock));

             if (m_exitFlag)
             
                 m_lock.unlock();
                 std::cout << "thread exiting" << std::endl;
                 return;
             

             std::function<void()> f;
             if (!m_queue.empty()) f = m_queue.front();

             m_lock.unlock;
             if (f != nullptr) f();
         
     
     Task(const Task&ref)  

     Task& operator=(const Task& ref) 
         return *this;
     
;
void foo() 
    Task tk;
    tk.start();

我想这里的某个地方存在竞争条件，因为它有时会崩溃，而另一些则不会。 一个线程在 ~Task() 中的关键区域内，另一个作为 Update1 中的堆栈。

【问题讨论】：

你能给我们一个完整的、可编译的例子来演示这个行为吗？最有可能的是，该错误正是您所读到的，但仅从这段代码很难分辨。 （如果你的代码在终止之前调用了join，比如~Task，它还会报错吗？）

您是否确定 start 没有被调用两次？尝试使用assert(!m_thread.joinable()) 保护它。错误的全文会很好。无关：std::bind 是不必要的，m_thread = std::thread(&Task::main_function, this); 将完成同样的事情。

你重载了复制构造函数，但没有重载赋值运算符！请永远不要这样做。

你是用多线程运行时编译的吗？

您的测试用例不是有效的 C++。请发布适当的测试用例。

【参考方案1】：

永远不要直接锁定互斥体。 C++ 提供lock_guard、unique_lock 等。是有原因的。

尤其是这一段是有问题的：

m_lock.lock();
while(m_queue.empty() && !m_exitFlag)
    m_condlock.wait(std::unique_lock<std::mutex>(m_lock));

新构建的unique_lock 将尝试锁定已经锁定的互斥锁m_lock。如果互斥锁是std::mutex，则为will cause undefined behavior；如果互斥锁为std::recursive_mutex，则可能出现死锁。 另请注意，当您绑定未命名的 unique_lock to a non-const reference when calling wait 时，此行依赖于非标准编译器扩展。

所以你要做的第一件事就是让锁成为一个命名变量。然后将std::adopt_lock 传递给锁的构造函数，或者更好的是永远不要直接锁定互斥体，而是始终将其包装在适当的锁管理类中。

例如，

m_lock.lock();
m_exitFlag = true;
m_condlock.notify_all();
m_lock.unlock();

变成

    std::lock_guard<std::mutex> lk(m_lock);
    m_exitFlag = true;
    m_condlock.notify_all();
 // mutex is unlocked automatically as the lock_guard goes out of scope

这还有一个额外的好处，即如果在临界区抛出异常，您就不会泄漏锁。

【参考方案2】：

您似乎从队列的 front() 中获取了一个函数，然后在解锁后运行该函数，而无需先使用 pop() 从队列中删除它。这是你的意图吗？在这种情况下，下一个随机线程也可能获取相同的函数并同时运行它。这些函数是线程安全的吗？此外，您检查 queue.empty() 但在执行后队列在哪里清空函数？