std ::线程导致应用程序中止错误R6010

std::thread causing application to abort with error R6010

本文关键字：错误 R6010 线程 std 应用程序      更新时间：2023-10-16

我有一个名为"任务"的类，该任务在内部容纳成员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));
}

问题在于，该行调用运行时错误R6010调用Abort（）。我在某个地方读到，这可能是由于m_thread的击离器而引起的。

我正在使用Visual Studio 2012

运行此操作

更新：

所以我尝试了一个测试示例，无法复制错误。然后，我在有问题的功能中替换了我的开始函数，因为这是这样做的：

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

update2：最终可以复制问题。代码如下。在主函数中调用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();
}

我想这里的某个地方有种族条件，因为它有时崩溃了，而其他情况则没有。一个线程在〜任务（）中的关键区域内，另一个线程作为Update1中的堆栈。

永远不要直接锁定互斥符。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。如果MUTEX是std::mutex或可能的僵局，则如果MUTEX为std::recursive_mutex，这将导致不确定的行为。另请注意，当您调用wait时，将未命名的unique_lock绑定到非const参考时，此行依赖于非标准编译器扩展程序。

因此，您要做的第一件事就是将锁定为命名变量。然后要么将std::adopt_lock传递到锁的构造函数，或者更好，但绝不会直接锁定Mutex，但始终将其包裹在适当的锁管理类中。

例如，

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

这具有额外的好处，如果在关键部分内抛出异常，您将不会泄漏锁定。

看来您从队列的前（）中获取一个函数，然后在解锁解锁后运行功能，而无需先用pop（）从队列中删除它。这是你的意图吗？在这种情况下，下一个随机线程也可以获取相同的功能并同时运行。这些功能是线程安全吗？另外，您检查了queue.empty（），但是执行功能后的队列在哪里排空？

相关文章：