标准：：抛线"resource dead lock would occur"

我有一个对象列表，每个对象都有由"update"函数计算的成员变量。我想并行地更新对象，也就是说，我想为每个对象创建一个线程来执行它的更新函数。

这样做合理吗？为什么这可能不是一个好主意？

下面是一个尝试执行我所描述的操作的程序，这是一个完整的程序，所以你应该能够运行它（我使用的是VS2015）。目标是并行更新每个对象。问题是，一旦更新函数完成，线程就会抛出"将发生资源死锁"异常并中止。

我哪里错了？

#include <iostream>
#include <thread>
#include <vector>
#include <algorithm>
#include <thread>
#include <mutex>
#include <chrono>
class Object 
{
public:
    Object(int sleepTime, unsigned int id)
        : m_pSleepTime(sleepTime), m_pId(id), m_pValue(0) {}
    void update()
    {
        if (!isLocked()) // if an object is not locked
        {
            // create a thread to perform it's update
            m_pThread.reset(new std::thread(&Object::_update, this));
        }
    }
    unsigned int getId()
    {
        return m_pId;
    }
    unsigned int getValue()
    {
        return m_pValue;
    }
    bool isLocked()
    {
        bool mutexStatus = m_pMutex.try_lock();
        if (mutexStatus) // if mutex is locked successfully (meaning it was unlocked)
        {
            m_pMutex.unlock();
            return false;
        }
        else // if mutex is locked
        {
            return true; 
        }
    }
private:
    // private update function which actually does work
    void _update()
    {
        m_pMutex.lock();
        {
            std::cout << "thread " << m_pId << " sleeping for " << m_pSleepTime << std::endl;
            std::chrono::milliseconds duration(m_pSleepTime);
            std::this_thread::sleep_for(duration);
            m_pValue = m_pId * 10;
        }
        m_pMutex.unlock();
        try
        {
            m_pThread->join();
        }
        catch (const std::exception& e)
        {
            std::cout << e.what() << std::endl; // throws "resource dead lock would occur"
        }
    }
    unsigned int m_pSleepTime;
    unsigned int m_pId;
    unsigned int m_pValue;
    std::mutex m_pMutex;
    std::shared_ptr<std::thread> m_pThread; // store reference to thread so it doesn't go out of scope when update() returns
};
typedef std::shared_ptr<Object> ObjectPtr;
class ObjectManager
{
public:
    ObjectManager()
        : m_pNumObjects(0){}
    void updateObjects()
    {
        for (int i = 0; i < m_pNumObjects; ++i)
        {
            m_pObjects[i]->update();
        }
    }
    void removeObjectByIndex(int index)
    {
        m_pObjects.erase(m_pObjects.begin() + index);
    }
    void addObject(ObjectPtr objPtr)
    {
        m_pObjects.push_back(objPtr);
        m_pNumObjects++;
    }
    ObjectPtr getObjectByIndex(unsigned int index)
    {
        return m_pObjects[index];
    }
private:
    std::vector<ObjectPtr> m_pObjects;
    int m_pNumObjects;
};
void main()
{
    int numObjects = 2;
    // Generate sleep time for each object
    std::vector<int> objectSleepTimes;
    objectSleepTimes.reserve(numObjects);
    for (int i = 0; i < numObjects; ++i)
        objectSleepTimes.push_back(rand());
    ObjectManager mgr;
    // Create some objects
    for (int i = 0; i < numObjects; ++i)
        mgr.addObject(std::make_shared<Object>(objectSleepTimes[i], i));
    // Print expected object completion order
    // Sort from smallest to largest
    std::sort(objectSleepTimes.begin(), objectSleepTimes.end());
    for (int i = 0; i < numObjects; ++i)
        std::cout << objectSleepTimes[i] << ", ";
    std::cout << std::endl;
    // Update objects
    mgr.updateObjects();
    int numCompleted = 0;  // number of objects which finished updating
    while (numCompleted != numObjects)
    {
        for (int i = 0; i < numObjects; ++i)
        {
            auto objectRef = mgr.getObjectByIndex(i);
            if (!objectRef->isLocked()) // if object is not locked, it is finished updating
            {
                std::cout << "Object " << objectRef->getId() << " completed. Value = " << objectRef->getValue() << std::endl;
                mgr.removeObjectByIndex(i);
                numCompleted++;
            }
        }
    }
    system("pause");
}