std :: thread导致应用程序中止错误R6010
我有一个名为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));
}
问题是该行使用运行时错误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：最后可能会重现该问题。 代码如下。 在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中的堆栈。
切勿直接锁定互斥锁。 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则会导致未定义的行为，如果mutex是std::recursive_mutex则会导致可能的死锁。 还要注意，这行代码依赖于非标准的编译器扩展，因为在调用wait时将未命名的unique_lock绑定到非const引用。
所以你必须做的第一件事是使锁定一个命名变量。 然后将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
这具有额外的好处，即如果在临界区域内引发异常，您将不会泄漏锁定。
看起来你从队列的front（）中取出一个函数，然后在解锁后运行该函数，而不是先用pop（）将它从队列中移除。 这是你的意图吗？ 在这种情况下，下一个随机线程也可能获得相同的功能并同时运行它。 这些函数是线程安全的吗？ 另外，你检查queue.empty（），但是在执行之后队列被清空了哪些函数呢？
链接地址: http://www.djcxy.com/p/78931.html上一篇: std::thread causing application to abort with error R6010