从另一个线程修改向量中指针的数据是否安全？

Question

事情似乎很有效，但我不确定这是否是最好的方法。

基本上我有一个异步数据检索的对象。该对象有一个指针向量，它们在主线程上分配和取消分配。使用 boost 函数，过程结果回调与该向量中的指针之一绑定。当它触发时，它将在某个任意线程上运行并修改指针的数据。

现在，我在推入向量并擦除的部分周围有一些关键部分，以防异步检索对象收到更多请求，但我想知道回调中是否需要某种类型的保护来修改指针数据。

希望这个精简的伪代码能让事情变得更清楚：

class CAsyncRetriever
{
    // typedefs of boost functions

    class DataObject
    {
         // methods and members
    };

public:
    // Start single asynch retrieve with completion callback
    void Start(SomeArgs)
    {
        SetupRetrieve(SomeArgs);
        LaunchRetrieves();
    }

protected:
    void SetupRetrieve(SomeArgs)
    {
            // ...

        { // scope for data lock
            boost::lock_guard<boost::mutex> lock(m_dataMutex);
            m_inProgress.push_back(SmartPtr<DataObject>(new DataObject)));
            m_callback = boost::bind(&CAsyncRetriever::ProcessResults, this, _1, m_inProgress.back());
        }

            // ...
    }

    void ProcessResults(DataObject* data)
    {
                // CALLED ON ANOTHER THREAD ... IS THIS SAFE?
        data->m_SomeMember.SomeMethod();
                data->m_SomeOtherMember = SomeStuff;
    }

    void Cleanup()
    {
                // ...

        { // scope for data lock
            boost::lock_guard<boost::mutex> lock(m_dataMutex);
            while(!m_inProgress.empty() && m_inProgress.front()->IsComplete())
                m_inProgress.erase(m_inProgress.begin());
        }

                // ...
         }

private:
    std::vector<SmartPtr<DataObject>> m_inProgress;
    boost::mutex m_dataMutex;
        // other members
};

编辑：这是 ProcessResults 回调的实际代码（加上注释以供您参考）

    void ProcessResults(CRetrieveResults* pRetrieveResults, CRetData* data)
        {
// pRetrieveResults is delayed binding that server passes in when invoking callback in thread pool
// data is raw pointer to ref counted object in vector of main thread (the DataObject* in question)

                // if there was an error set the code on the atomic int in object
            data->m_nErrorCode.Store_Release(pRetrieveResults->GetErrorCode());

                // generic iterator of results bindings for generic sotrage class item
            TPackedDataIterator<GenItem::CBind> dataItr(&pRetrieveResults->m_DataIter);
                // namespace function which will iterate results and initialize generic storage
            GenericStorage::InitializeItems<GenItem>(&data->m_items, dataItr, pRetrieveResults->m_nTotalResultsFound); // this is potentially time consuming depending on the amount of results and amount of columns that were bound in storage class definition (i.e.about 8 seconds for a million equipment items in release)
                // atomic uint32_t that is incremented when kicking off async retrieve
            m_nStarted.Decrement(); // this one is done processing

                // boost function completion callback bound to interface that requested results
            data->m_complete(data->m_items);
        }

Answer 1

就目前情况而言，Cleanup 代码似乎可以销毁正在执行 ProcessResults 回调的对象。当您在回调中取消引用指针时，这会导致问题。

我的建议是，您扩展 m_dataMutex 的语义以包含回调，但如果回调长时间运行，或者可能在 SetupRetrieve 中内联发生（有时这确实如此）发生 - 虽然在这里你声明回调是在不同的线程上，在这种情况下你没问题）然后事情就更复杂了。目前，m_dataMutex 对于它是否控制对向量或其内容或两者的访问有点困惑。明确其范围后，可以增强 ProcessResults 以验证锁内有效负载的有效性。

Answer 2

不，这不安全。

ProcessResults 对通过DataObject 传递给它的数据结构进行操作。它表明您在不同线程之间共享状态，如果两个线程同时对数据结构进行操作，您可能会遇到一些麻烦。

Answer 3

更新指针应该是一个原子操作，但您可以使用 InterlockedExchangePointer（在 Windows 中）可以肯定。不确定 Linux 的等价物是什么。

唯一需要考虑的是一个线程是否正在使用过时的指针。另一个线程是否删除了原指针所指向的对象？如果是这样，那么你肯定有问题。