blocks|key|257164|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|257165|如何开发线程安全的生产者/消费者模式？|blockquote|257166|257167|257168|有几种方法，但使用locks+and+monitors相当容易掌握，并且没有太多隐藏的注意事项。标准库使用std::unique_lock、std::lock_guard和std::condition_variable来实现该模式。有关简单的示例，请查看condition_variable的of首选项页面。|offset|length|style|CODE|257169|257170|是std::deque是安全的吗？|257171|257172|257173|这不安全。你需要同步。|257174|257175|是否可以在一个线程中使用push_back连接到双队列的后面，而在另一个线程中使用push_front？|257176|257177|257178|当然可以，但你需要同步。当队列为空或只有一个元素时，存在竞争条件。此外，当队列已满或不足一个，以防您想要限制它的大小。|257179|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Monitor_%2528synchronization%2529|1|http://en.cppreference.com/w/cpp/thread/condition_variable^0|0|0|0|0|1H|G|1Y|F|2E|N|9|I|0|3J|I|1|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|19|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1A|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1B|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1D|7|@$H|1E|I|1F|J|K]|$H|1G|I|1H|J|K]|$H|1I|I|1J|J|K]]|8|@$H|1K|I|1L|1|1M]|$H|1N|I|1O|1|1P]]|9|$]]|$1|L|3|-4|4|5|6|1Q|7|@]|8|@]|9|$]]|$1|M|3|N|4|C|6|1R|7|@]|8|@]|9|$]]|$1|O|3|-4|4|5|6|1S|7|@]|8|@]|9|$]]|$1|P|3|-4|4|5|6|1T|7|@]|8|@]|9|$]]|$1|Q|3|R|4|5|6|1U|7|@]|8|@]|9|$]]|$1|S|3|-4|4|5|6|1V|7|@]|8|@]|9|$]]|$1|T|3|U|4|C|6|1W|7|@]|8|@]|9|$]]|$1|V|3|-4|4|5|6|1X|7|@]|8|@]|9|$]]|$1|W|3|-4|4|5|6|1Y|7|@]|8|@]|9|$]]|$1|X|3|Y|4|5|6|1Z|7|@]|8|@]|9|$]]|$1|Z|3|-4|4|5|6|20|7|@]|8|@]|9|$]]]|10|$11|$4|12|13|14|9|$15|16]]|17|$4|12|13|14|9|$15|18]]]]

<blockquote>
 How Can I develop a producer/ consumer pattern which is thread safe?
</blockquote>

There are several ways, but using <a href="http://en.wikipedia.org/wiki/Monitor_%28synchronization%29" rel="nofollow">locks and monitors</a> is fairly easy to grasp and doesn't have many hidden caveats. The standard library has <code>std::unique_lock</code>, <code>std::lock_guard</code> and <code>std::condition_variable</code> to implement the pattern. Check out the cppreference page of <a href="http://en.cppreference.com/w/cpp/thread/condition_variable" rel="nofollow">condition_variable</a> for simple example.

<blockquote>
 Is std::deque is safe for this purpose?
</blockquote>

It's not safe. You need synchronization.

<blockquote>
 can I push_back to the back of a deque in one thread and push_front in another thread?
</blockquote>

Sure, but you need synchronization. There is a race condition when the queue is empty or has only one element. Also when the queue is full or one short of full in case you want to limit it's size.

blocks|key|130018|text|我想你是指push_back()和pop_front()吧。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|130019|std::deque本身不是线程安全的。您将需要使用std::mutex序列化访问，这样消费者就不会在生产者尝试推送时尝试弹出。|130020|您还应该考虑如何处理以下问题：|130021|130022|当消费者寻找下一件商品时，如果队列是空的，它会怎么做？|ordered-list-item|130023|130024|如果它进入等待状态，那么您将需要一个std::condition_variable，以便在添加了该双队列时由生产者通知。您可能还需要处理程序终止，在此过程中，消费者正在等待双队列，而程序被终止。除非你正确地安排了事情，否则它可能会“永远等待”。|130025|10个项目是“无关紧要的”，所以我不会为预留空间而烦恼。std::deque会自动地增长和缩小，所以在构建一个可以工作的应用程序之前，请不要费心进行细粒度调整。|130026|130027|过早优化是万恶之源。|blockquote|130028|130029|130030|注意:不清楚你是如何限制队列大小的，但是如果生产者填满了队列，然后等待它清空，你将需要更多的等待和条件，以另一种方式来协调。|130031|entityMap^0|5|B|H|B|0|0|A|Q|A|0|0|0|0|0|I|N|0|S|A|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1C|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|1E|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]|$1|T|3|U|5|V|7|1N|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|11|$]]

I think you mean <code>push_back()</code> and <code>pop_front()</code>. 

<code>std::deque</code> is not thread-safe on its own.
You will need to serialise access using an <code>std::mutex</code> so the consumer isn't trying to pop while the producer is trying to push.

You should also consider how you handle the following:

<ol>
<li>How does the consumer behave if the deque is empty when it looks for the next item?</li>
</ol>

If it enters a wait state then you will need a <code>std::condition_variable</code> to be notified by the producer when the deque has been added to.
You may also need to handle program termination in which the consumer is waiting on the deque and the program is terminated. It could be left 'waiting forever' unless you orchestrate things correctly.

10 items is 'piffle' so I wouldn't bother about reserving space. <code>std::deque</code> grows and shrinks automatically so don't bother with fine grain tuning until you've built a working application.

<blockquote>
 Premature optimization is the root of all evil.
</blockquote>

NB: It's not clear how your limiting the queue size but if the producer fills up the queue and then waits for it to clear back down you'll need more waits and conditions coming back the other way to coordinate.

blocks|key|130037|text|STL+C%2B%2B容器不是线程安全的:如果您决定使用它们，则在推送/弹出元素时需要使用适当的同步(基本上是std::mutex和std::lock)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|130038|或者，您可以使用适当设计的容器(单生产者-单消费者队列应该能满足您的需求)，这里有一个这样的例子：http://www.boost.org/doc/libs/1_58_0/doc/html/lockfree.html|130039|编辑后添加：|130040|是的，SPSC队列基本上就是一个环形缓冲区，非常适合您的需要。|130041|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_58_0/doc/html/lockfree.html^0|1F|A|1Q|9|0|1D|1N|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|H|3|I|5|6|7|12|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|13|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]]]

STL C++ containers are not thread-safe: if you decide for them, you need to use proper synchronizations (basically <code>std::mutex</code> and <code>std::lock</code>) when pushing/popping elements.

Alternatively you can use properly designed containers (single-producer-single-consumer queues should fit your needs), one example of them here: <a href="http://www.boost.org/doc/libs/1_58_0/doc/html/lockfree.html" rel="nofollow">http://www.boost.org/doc/libs/1_58_0/doc/html/lockfree.html</a>

addon after your EDIT:

yep, a SPSC queue is basically a ring buffer and definitively fits you needs.

How Can I develop a producer/ consumer pattern which is thread safe?
in my case, the producer runs in a thread and the consumer runs on another thread.
Is std::deque is safe for this purpose?
can I push_back to the back of a deque in one thread and push_front in another thread?
<h1>Edit 1</h1>
In my case, I know the maximum number of items in the std::deque (for example 10). Is there any way that I can reserve enough space for items beforehand so during processing, there was no need to change the size of queue memory and hence make sure when I am adding pushing data to back, no change could be happen on front data?

thread safe producer/consumer pattern in c++

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如何开发线程安全的生产者/消费者模式？在我的例子中，生产者在一个线程中运行，而消费者在另一个线程中运行。std::deque用于此目的安全吗？我可以在一个线程中push_back到一个双端队列的后面，而在另一个线程中执行push_front吗？编辑1在我的例子中，我知道std::deque中的最大项目数(例如10)。有...

问c++中的线程安全生产者/消费者模式
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问c++中的线程安全生产者/消费者模式EN