C++ tbb:：concurrent_队列容器中std:：deque at的等价物？

我使用std:：dequeat函数访问元素，而不会从队列中弹出，因为我在不同的迭代中使用相同的队列。我的解决方案基于粗粒度多线程。现在我想让它成为细粒度的多线程解决方案。为此，我使用tbb:：concurrent_队列。但是我需要tbb:：concurrent_队列中std:：dequeat操作的等价函数

编辑 这就是我如何使用std:：deque（粗粒度多线程）实现的 请记住，dq是静态队列（即在不同迭代中多次使用）

vertext\u found=true；
标准：德克dq；
而（isize（））
{
肠危重科（&h）；
如果（i

---

我想用tbb:：concurrent_queue获得相同的结果？

根据tbb站点（）中的Doxygen文档，队列中没有操作

。您可以使用
tbb:：strict\u ppl:：concurrent\u queue
推送
和
try\u pop
元素

如果您使用的是
tbb:：deprecated:：concurrent_queue
（tbb的旧版本），则可以使用
push_If_not_full
和
pop_If_present
操作

在这两个队列中，“多个线程可以同时推送和弹出”，如简要部分所述。
根据TBB站点（）中的Doxygen文档，队列中的
没有操作。您可以使用
tbb:：strict\u ppl:：concurrent\u queue
推送
和
try\u pop
元素

如果您使用的是
tbb:：deprecated:：concurrent_queue
（tbb的旧版本），则可以使用
push_If_not_full
和
pop_If_present
操作

在这两个队列中，“多个线程可以每个推和并发”，如在简短章节中所述。
 < P>如果您的算法有单独的队列填充队列或消耗队列，请考虑使用TBB::CONTRONTURN向量。它有一个push_back方法可用于填充过程，还有一个at（）方法可用于消耗过程。如果线程与消耗传递中的POP元素竞争，请考虑使用TBB::Author计数器生成AT.（）/<
如果填充和消费之间没有如此清晰的分离，使用at（）可能会产生比它解决的问题更多的问题，即使它存在，因为它将与消费者竞争

如果一个消耗通道只需要并行循环并发向量，考虑使用TBB:：concurrent_vector有一个range（）方法支持这种习惯用法
void consume( tbb::concurrent_vector<T>& vec ) {
    tbb::parallel_for( vec.range(), [&]( const tbb::concurrent_vector<T>::range_type& r ) {
        for( auto i=r.begin(); i!=r.end(); ++i ) {
            T value = *i;
            ...process value...;
        }
    });
}

void消费（tbb:：concurrent_vector&vec）{
tbb:：parallel_for（vec.range（），[&]（常量tbb:：concurrent_vector:：range_type&r）{
对于（自动i=r.begin（）；i！=r.end（）；++i）{
T值=*i；
…过程价值。。。；
}
});
}

如果消耗通道不使用TBB:Apple，请考虑使用TBB原子计数器来生成索引。将计数器初始化为零，并使用++将其递增。以下是一个例子：
tbb::atomic<size_t> head;
tbb::concurrent_vector<T> vec;

bool pop_one( T& result ) { // Try to grab next item from vec
    size_t i = head++;      // Fetch-and-increment must be single atomic operation
    if( i<vec.size() ) {
        result = vec[i];
        return true;
    } else {
        return false;       // Failed
    }
}

tbb:：原子头；
tbb：：并发向量向量向量；
bool pop_one（T&result）{//尝试从vec获取下一项
size_t i=head++；//获取和增量必须是单个原子操作
如果（i）p>如果你的算法有单独的队列，它会填充队列或消耗队列，那么考虑使用TBB::CONTURNTHORY矢量。它有一个可以用于填充通道的推送方法，和一个AT-（）。方法：如果线程与消费通道中的POP元素竞争，请考虑使用TBB::Author计数器生成AT.（）/<
如果填充和消费之间没有如此清晰的分离，使用at（）可能会产生比它解决的问题更多的问题，即使它存在，因为它将与消费者竞争

如果一个消耗通道只需要并行地循环并发向量，考虑使用TBB::LoopyOFF用于循环。TBB:：CONTURNSONTY向量有一个支持这个成语的Range（）方法。
void consume( tbb::concurrent_vector<T>& vec ) {
    tbb::parallel_for( vec.range(), [&]( const tbb::concurrent_vector<T>::range_type& r ) {
        for( auto i=r.begin(); i!=r.end(); ++i ) {
            T value = *i;
            ...process value...;
        }
    });
}

void消费（tbb:：concurrent_vector&vec）{
tbb:：parallel_for（vec.range（），[&]（常量tbb:：concurrent_vector:：range_type&r）{
对于（自动i=r.begin（）；i！=r.end（）；++i）{
T值=*i；
…过程价值。。。；
}
});
}

如果消耗通道不使用TBB:Apple，请考虑使用TBB原子计数器来生成索引。将计数器初始化为零，并使用++来增加它。这里有一个例子：
tbb::atomic<size_t> head;
tbb::concurrent_vector<T> vec;

bool pop_one( T& result ) { // Try to grab next item from vec
    size_t i = head++;      // Fetch-and-increment must be single atomic operation
    if( i<vec.size() ) {
        result = vec[i];
        return true;
    } else {
        return false;       // Failed
    }
}

tbb:：原子头；
tbb：：并发向量向量向量；
bool pop_one（T&result）{//尝试从vec获取下一项
size_t i=head++；//获取和增量必须是单个原子操作
如果（这里也有
tbb:：concurrent\u bounded\u queue
，但它也没有
at
方法。似乎只有
at
的tbb容器是
tbb:：concurrent\u vector
。是的，我知道push和try\u pop是可用的。但这会修改队列，因此性能会降低。我无法访问conc的元素没有pop操作的当前\u队列？还有
tbb:：concurrent\u bounded\u队列
，但它也没有
at
方法。唯一一个似乎在
at
有
tbb:：concurrent\u vector
的tbb容器是
。如果没有pop操作，我无法访问并发_队列的元素？它没有单独的阶段..填充队列是一次性操作..然后