C++ 多线程和向量

Question

我尝试了以下算法的各种实现，但在程序运行一段时间后总是以崩溃告终...

我有一个基础对象

class Element
    {
    public:
        int a;
        float p;
        Element(int _a, float _p=1.0): a(_a), p(_p){};
    };

我创建了一个向量并包含在一个 Buffer 对象中。

class Buffer
    {
    public:
        Buffer(){};

        vector<Element> raw;       
        vector<Element> optimised; // DATA CALCULATED BASED ON RAW

        void addElement(int _a,float _p=1.0) // FILL THE RAW BUFFER
        {
            raw.push_back(Element(_a,_p));
        }

        void compute()  // COMPUTE THE OPTIMISED BUFFER
        {
            float t;
            int i;
            for(std::vector<Element>::iterator it = raw.begin(); it != raw.end(); ++it) 
            {
                optimised.push_back(Element(it->a,it->p));
                // DO SOME COMPUTATIONALLY INTENSIVE CALCULATIONS
                for(i=1; i<9999999; i++)
                    t = 9./i;
            }
        };

        void clear() // ERASE BOTH BUFFERS
        {
            raw.clear();
            optimised.clear();
        }
    };

我声明了一个 Buffer 对象 - 负责捕获当前数据流 - 和一个 Buffer 对象向量 - 其行为类似于先前创建的缓冲区的历史记录/队列。

Buffer buffer;
vector<Buffer> queue;

主线程负责填充缓冲区对象，并且 - 一旦系列完成 - 将缓冲区提交到队列中。 一旦将新缓冲区添加到队列中，就会在单独的线程上调用 Compute() 函数来分析最近提交的数据。

//ADD THE CURRENT BUFFER TO THE QUEUE
queue.push_back(buffer);

//RUN 'COMPUTE' IN PARALLEL/BACKGROUND ON THE LAST SUBMITTED BUFFER
std::thread t(&Buffer::compute, &queue.back());
t.detach();

//CLEAR THE BUFFER, READY FOR A NEW SERIES
buffer.clear();

---

程序正常运行并启动，但在执行过程中崩溃（有时只提交一个缓冲区，有时提交几个......如果只有一个缓冲区，它通常“工作更长时间”一次在队列中）。

在这种情况下我需要使用互斥锁吗？如果有，在哪里？

您对如何优化数据收集有任何建议（填充“缓冲区”对象并将其提交到队列中） - 我认为 AddElement() 有点不必要地昂贵？

任何帮助表示赞赏！

谢谢

Answer 1

问题在于&queue[last]。这为您提供了一个指向向量当前存储缓冲区的位置的指针。如果向量重新分配（push_back 可以这样做），则指针无效。

有几个解决方案：

• 将指针存储在queue 向量中。 vector<unique_ptr<Buffer>> queue 之类的东西会起作用（并确保您不会意外泄漏内存）。
• 使用不会使指针在修改时无效的数据结构。 list 和 deque 可以工作。
• 确保向量不会重新分配。您可以先发送resize(x)，然后自己跟踪最后一次。

更新：添加代码示例。这在 Coliru (http://coliru.stacked-crooked.com/) 上编译并运行良好

#include <memory>
#include <vector>
#include <iostream>
class Buffer {};

int main()
{
    std::unique_ptr<Buffer> buffer {new Buffer()};
    std::vector<std::unique_ptr<Buffer>> queue;
    for (int i = 0; i < 10; i++) {
        buffer.reset(new Buffer());
        // Do things to buffer;
        queue.push_back(move(buffer));
    }
    std::cout << queue.size() << std::endl;
}