问题描述
我想要两个线程如下:
- 第一个线程会将值附加到向量
- 第二个线程将通过索引对元素进行只读访问
我可以在第二个线程开始读取之前进行互斥并进行深度复制....但这种方式真的很慢...怎么可能使这没有互斥?这里:
我读到这是可能的使用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 }
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 }
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];
}
};我的解决方案是否安全?
您的解决方案不是线程安全的,没有锁定机制。
您可以使用或同时进行多个插入和访问。无需额外锁定。从这些向量中删除元素是不安全的,但你可以确定它。我猜。
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多线程使用的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持!