QList，QVector或std :: vector多线程使用 [英] QList, QVector or std::vector multi-threaded usage

问题描述

我想要两个线程如下：

1. 第一个线程会将值附加到向量


2. 第二个线程将通过索引对元素进行只读访问

我可以在第二个线程开始读取之前进行互斥并进行深度复制....但这种方式真的很慢...怎么可能使这没有互斥？这里： STL向量和线程安全
我读到这是可能的使用std :: deque，但它失败像std :: vector ...

在哪里可以找到append-only容器，这不是realloc数据？ / p>

---

我已经解决了我的问题，创建自己的容器GrowVector与操作：添加元素回，获得大小， 。它适用于默认的2Billion元素，但可以通过构造函数参数更改。

  #include< vector& 
 
 template< typename T> 
 class GrowVector 
 {
 std :: vector< std :: vector< T& > m_data; 
 size_t m_size; 
 
 public：
 GrowVector（int chunks = 32768）
：m_data（）
，m_size（0）
 {
 m_data.reserve （块）。 
 m_data.push_back（std :: vector< T>（））; 
 m_data.back（）。reserve（1 << 16）; 
} 
 
 void add（const T& value）
 {
 if（m_data.back（）。size（）== m_data.back（）。 capacity（））
 {
 m_data.push_back（std :: vector< T>（））; 
 m_data.back（）。reserve（1 << 16）; 
} 
 
 m_data.back（）。push_back（value）; 
 m_size ++; 
} 
 
 size_t size（）const 
 {
 return m_size; 
} 
 
 T& operator []（int i）
 {
 return m_data [i> 16] [i& 0xffff]; 
} 
 
 const T& operator []（int i）const 
 {
 return m_data [i> 16] [i& 0xffff]; 
} 
};我的解决方案是否安全？
 
 
 
 
 <解决方案
您的解决方案不是线程安全的，没有锁定机制。
 
 
 
您可以使用 tbb :: concurrent_vector 或 Concurrency :: concurrent_vector 同时进行多个插入和访问。无需额外锁定。从这些向量中删除元素是不安全的，但你可以确定它。我猜。
 
I would like two threads work like this:

First thread will append values to vector
Second thread will have read-only access to elements by index
I can make mutex and make deep copy before second thread start reading.... But this way is really slow... How is it possible to make this without mutex? Here: STL vector and thread-safety
I read that it is possible to use std::deque, but it fails like std::vector ...

Where I can find append-only container, which don't realloc data?



I have solved my problem by creating own container GrowVector with operations: adding elements to back, getting size, accessing element by index. It works for 2Billion elements for default, but it can be changed by constructor parameter.
#include <vector>

template<typename T>
class GrowVector
{
    std::vector<std::vector<T> > m_data;
    size_t m_size;

public:
    GrowVector(int chunks = 32768)
        : m_data()
        , m_size(0)
    {
        m_data.reserve(chunks);
        m_data.push_back(std::vector<T>());
        m_data.back().reserve(1 << 16);
    }

    void add(const T & value)
    {
        if (m_data.back().size() == m_data.back().capacity())
        {
            m_data.push_back(std::vector<T>());
            m_data.back().reserve(1 << 16);
        }

        m_data.back().push_back(value);
        m_size++;
    }

    size_t size() const
    {
        return m_size;
    }

    T & operator [] (int i)
    {
        return m_data[i >> 16][i & 0xffff]; 
    }

    const T & operator [] (int i) const
    {
        return m_data[i >> 16][i & 0xffff];    
    }
};
Is my solution safe?
解决方案
Your solution is not thread-safe without a locking mechanism.

You can use tbb::concurrent_vector or Concurrency::concurrent_vector for multiple insertion and access simultaneously. No extra locking required. It is unsafe to erase elements from those vectors, but you are ok with it I guess.

                        
这篇关于QList，QVector或std :: vector多线程使用的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！