Question

特别是，我正在寻找一个阻塞队列。 C ++ 11中有这样的东西吗？如果没有，我的其他选择是什么？我真的不想再去自己的线程了。方式太容易出错。

Answer 1

According to Diego Dagum from Microsoft's Visual C++ Team：

一个反复出现的问题（好吧，其中一个）是关于STL容器的   以及它们是否是线程安全的。

在这里采用斯蒂芬的话，现实是他们不是，而不是   但是作为一个特征：拥有每个STL的每个成员函数   容器获取内部锁将消灭性能。如   一个通用的，高度可重用的库，它实际上不会   提供正确性：正确的锁定级别是   由程序正在做什么决定。在这个意义上，个人   成员函数往往不是那么正确。

The Parallel Patterns Library（PPL）包括几个容器，这些容器提供对其元素的线程安全访问：

concurrent_vector Class是一个序列容器类，允许随机访问任何元素。它支持并发安全追加，元素访问，迭代器访问和迭代器遍历操作。
concurrent_queue Class是一个序列容器类，允许以先进先出的方式访问其元素。它支持一组有限的并发安全操作，例如push和try_pop，仅举几例。

部分样本here。

同样有趣：http://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html。

Answer 2

C ++ 11本身不提供并发容器。但是，有库选项。除了已经提到的PPL之外，不要忘记英特尔TBB库。

它有一个并发的queue，hash_map，set和vector实现。但它不仅是一个线程安全的容器库，它还带有并行版本的标准算法（for-loop，reduce，sort，......）。

Intel TBB website

Answer 3

我很惊讶没有人提到moodycamel::ConcurrentQueue。我们已经使用它已经有一段时间了，它表现得非常好。具体而言，它的实现是无锁的，这会立即带来巨大的速度。使用它的其他原因（引自官方网站）：

C ++没有那么多完整的无锁队列。促进有一个，但它仅限于具有普通赋值运算符的对象例如，琐碎的析构函数。英特尔的TBB队列不是无锁，也需要琐碎的构造函数。有很多学术论文，用C ++实现无锁队列，但可用源代码很难找到，测试更是如此。

可以使用here，here和here进行一些基准测试和比较。

Answer 4

容器的界面根本没有设计用于此目的。对于他们使用的接口，客户端可见的锁定确实是在保证正确性和可预测行为的同时实现此目的的唯一方法。它的效率也非常低，因为收购的数量非常高（相对于良好的实施而言）。

解决方案1 

按值传递（如果适用）。

解决方案2

创建一组简单的bolt-on实现，可以在持有作用域锁时传递容器（请考虑伪c ++）：

template <typename TCollection>
class t_locked_collection {
public:
    t_locked_collection(TCollection& inCollection, t_lock& lock) : collection(inCollection), d_lock(lock), d_nocopy() {
    }

    TCollection& collection;
    // your convenience stuff
private:
    t_scope_lock d_lock;
    t_nocopy d_nocopy;
};

然后调用者将锁与集合配对，然后更新接口以在适当的位置使用（传递）容器类型。这只是一个穷人的阶级延伸。

这个锁定的容器就是一个简单的例子，还有一些其他的变种。这是我选择的路由，因为它确实允许您使用适合您的程序的粒度级别，即使它不像锁定方法那样透明（语法上）。调整现有程序也相对容易。至少它以可预测的方式运行，与具有内部锁的集合不同。

另一种变体是：

template <typename TCollection>
class t_lockable_collection {
public:
// ...
private:
    TCollection d_collection;
    t_mutex d_mutex;
};

// example:
typedef t_lockable_collection<std::vector<int> > t_lockable_int_vector;

...其中类似于t_locked_collection的类型可用于公开底层集合。并不是说这种方法是万无一失的，只是傻瓜式的。

Answer 5

我的并发无序地图版本命名空间并发 {

template<typename T,typename T1>
class unordered_bucket: private std::unordered_map<T,T1>
{
mutable std::recursive_mutex m_mutex;

public:
T1 &operator [](T a)
{
    std::lock_guard<std::recursive_mutex> l(m_mutex);
    return std::unordered_map<T,T1>::operator [](a);
}

size_t size() const noexcept {
    std::lock_guard<std::recursive_mutex> l(m_mutex);
    return  std::unordered_map<T,T1>::size();
}

vector<pair<T,T1>> toVector() const
{
    std::lock_guard<std::recursive_mutex> l(m_mutex);

    vector<pair<T,T1>> ret;
    for(const pair<T,T1> &p:*this)
    {
        ret.push_back(p);
    }
    return ret;
}

bool find(const T &t) const
{
    std::lock_guard<std::recursive_mutex> l(m_mutex);
    if(this->std::unordered_map<T,T1>::find(t) == this->end())
        return false;  //not found
    return true;
}
void erase()
{
    std::lock_guard<std::recursive_mutex> l(m_mutex);
    this->unordered_map<T,T1>::erase(this->begin(),this->end());
}
void erase(const T &t)
{
    std::lock_guard<std::recursive_mutex> l(m_mutex);
    this->unordered_map<T,T1>::erase(t);
}
};

#define BUCKETCOUNT 10
template<typename T,typename T1>
class ConcurrentMap
{
std::vector<unordered_bucket<T,T1>> m_v;
public:
ConcurrentMap():m_v(BUCKETCOUNT){}   //using 10 buckets

T1 &operator [](T a)
{
    std::hash<T> h;
    return m_v[h(a)%BUCKETCOUNT][a];
}

size_t size() const noexcept {
    size_t cnt=0;

    for(const unordered_bucket<T,T1> &ub:m_v)
        cnt=cnt+ub.size();

    return  cnt;
}

vector<pair<T,T1>> toVector() const
{
    vector<pair<T,T1>> ret;
    for(const unordered_bucket<T,T1> &u:m_v)
    {
        const vector<pair<T,T1>> &data=u.toVector();
        ret.insert(ret.end(),data.begin(),data.end());
    }
    return ret;
}

bool find(const T &t) const
{
    for(const unordered_bucket<T,T1> &u:m_v)
        if(true == u.find(t))
            return true;
    return false;
}
void erase()
{
    for(unordered_bucket<T,T1> &u:m_v)
        u.erase();
}
void erase(const T &t)
{
    std::hash<T> h;
    unordered_bucket<T,T1> &ub = m_v[h(t)%BUCKETCOUNT];
    ub.erase(t);
}
};
}

Answer 6

C ++ 11中没有并发容器。

但是以下标头类使用std :: deque提供并发队列，堆栈和优先级容器。

BlockingCollection是一个C ++ 11线程安全集合类，它以.NET BlockingCollection类为模型。

C ++ 11中是否有任何并发容器？

6 个答案:

C ++ 11中是否有任何并发​​容器？

6 个答案:

C ++ 11中是否有任何并发容器？