使用者/生产者锁定GUI线程
使用者/生产者锁定GUI线程是指在图形用户界面（GUI）应用程序中，使用者（用户）和生产者（程序）之间存在一种同步机制，以确保GUI线程的安全性和响应性。
在GUI应用程序中，GUI线程负责处理用户界面的绘制和事件响应，而生产者线程则负责执行后台任务或处理数据。当使用者（用户）与生产者（程序）之间存在交互时，需要确保GUI线程的稳定性和响应性，以避免用户界面的卡顿或崩溃。
为了实现使用者/生产者锁定GUI线程，可以采用以下方法：
- 使用线程安全的数据结构：在生产者线程和GUI线程之间共享数据时，使用线程安全的数据结构，如线程安全的队列（ConcurrentQueue）或线程安全的集合（ConcurrentDictionary），以确保数据的安全访问和更新。
- 使用同步机制：使用同步机制，如互斥锁（Mutex）或信号量（Semaphore），在生产者线程和GUI线程之间进行同步，以避免竞态条件和数据访问冲突。
- 使用异步编程模型：将生产者线程的任务或处理过程设计为异步操作，以避免阻塞GUI线程。可以使用异步关键字（async）和等待关键字（await）来实现异步编程。
- 使用事件驱动模型：使用事件驱动模型，将生产者线程和GUI线程解耦，通过事件机制进行通信。当生产者线程完成任务或产生数据时，触发相应的事件，GUI线程订阅事件并响应。
使用者/生产者锁定GUI线程的优势包括：
- 提高用户界面的响应性：通过将耗时的任务或数据处理过程放在生产者线程中执行，可以避免阻塞GUI线程，提高用户界面的响应速度和流畅性。
- 提高程序的稳定性：通过使用同步机制和线程安全的数据结构，可以避免竞态条件和数据访问冲突，提高程序的稳定性和可靠性。
- 改善用户体验：通过确保GUI线程的稳定性和响应性，可以提供更好的用户体验，减少用户界面的卡顿和崩溃现象。
使用者/生产者锁定GUI线程的应用场景包括：
- 图形界面应用程序：适用于需要处理大量数据或执行耗时任务的图形界面应用程序，如图像处理软件、视频编辑软件等。
- 多线程数据处理：适用于需要在后台线程中进行数据处理或计算的应用程序，如数据分析、科学计算等。
- 异步操作：适用于需要在后台执行异步操作的应用程序，如网络请求、文件读写等。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云云服务器（CVM）：提供弹性计算能力，支持按需购买和预付费模式，适用于各类应用场景。详情请参考：https://cloud.tencent.com/product/cvm
- 腾讯云云数据库MySQL版：提供高性能、高可用的MySQL数据库服务，支持自动备份和容灾能力，适用于各类应用场景。详情请参考：https://cloud.tencent.com/product/cdb_mysql
- 腾讯云容器服务（TKE）：提供高度可扩展的容器集群管理服务，支持容器化应用的部署和管理，适用于云原生应用场景。详情请参考：https://cloud.tencent.com/product/tke
请注意，以上仅为腾讯云的部分产品示例，其他云计算品牌商也提供类似的产品和服务。
相关·内容
显然，我对条件变量和如何使用这些变量有了错误的理解。我的意图是有一个生产者和多个消费者线程，但是我可以用一个生产者和一个消费者来演示我的问题。
有一个名为work的共享变量，它由互斥变量和条件变量保护。生产者设置work变量并表示它已经准备好了，但是使用者线程永远不会运行？
如果程序工作正常，它应该打印this line never get's printed，但是我得到了consumer never did work...giving up。如能提供任何协助，将不胜感激。
#include <stdio.h>
#include <string.h>
#incl
浏览 3提问于2015-09-15得票数 0
回答已采纳
目标:-实现arduino与C++程序之间的串行通信。我使用处理作为一个中间程序，它对数据执行一些操作，然后将这些值串行地传递给arduino！
我有一个C++程序，它定期将数据写入文件，例如，每30毫秒将UFR,90,87写入文件。正在写入的文件以截断模式完成，即每30 ms覆盖一次文件。
接下来，有一个处理代码，它必须在编写文件后立即从文件中获取该值。首先执行C++代码，然后执行处理代码。处理代码使用BufferedReader读取文件的内容。
我应该如何启用两个程序之间的同步，以便通过处理代码同时读取C++程序刚刚写入的值(稍微滞后，小于5-10 ms是可以接受的)，并且存在完美的同步？
浏览 4提问于2015-02-13得票数 1
我的线程不需要被锁定。std::unique_lock在结构上锁定线程。我只是使用cond_var.wait()作为一种避免繁忙等待的方法。我基本上绕过了自动锁定，将unique_lock放在一个很小的范围内，从而在它离开这个小范围后销毁了唯一的锁。此外，如果与相关，则只有一个使用者线程。
{
std::unique_lock<std::mutex> dispatch_ul(dispatch_mtx);
pq_cond.wait(dispatch_ul);
}
是否有更好的选择来避免unique_lock不必要的自动锁定功能？我正在寻找一个无互斥选项来简单地发送线程信号，我知道，但
浏览 16提问于2022-03-02得票数 1
回答已采纳
3回答
在C中，我有几个线程生成 long值，而一个线程使用值。因此，我需要一个与类似的固定大小的缓冲区，以及以线程安全的方式访问它的方法。
在一般情况下，应采取以下措施：
当添加到完整缓冲区时，线程应该被阻塞(不覆盖旧值)。
使用者线程应该被阻塞，直到缓冲区满了--它的任务具有很高的恒定成本，并且应该做尽可能多的工作。(这需要双缓冲的解决方案吗？)
我想使用一个尝试的实现，最好是从一个库。有什么想法吗？
动机和解释：
我正在编写JNI代码，处理如何删除堆对象中作为保存的。
当发生ObjectFree JVMTI事件时，我将得到一个long标记，该标记表示需要使用DeleteGlob
浏览 7提问于2012-08-28得票数 4
回答已采纳
请参阅下列经典生产者-消费者代码：
int main()
{
std::queue<int> produced_nums;
std::mutex m;
std::condition_variable cond_var;
bool done = false;
bool notified = false;
std::thread producer([&]() {
for (int i = 0; i < 5; ++i) {
std::this_thread::sleep_for(std
浏览 0提问于2018-05-21得票数 6
回答已采纳
我如何确保生产者和消费者的功能无限地、一个接一个地运行？例如:首先，我希望用户输入数组，然后使用者函数打印输入的数组，然后再次要求用户输入数组。
/* Headers */
pthread_mutex_t mutex;
pthread_cond_t cond,cond1;
void *producer(void *arg);
void *consumer(void *arg);
static int n;
int consumerFlag[100];
void *producer(void *arg)
{
pthread_mutex_lock(&mutex);
浏览 0提问于2019-04-11得票数 0
回答已采纳
当producer()中的睡眠调用未注释时，有人能解释为什么这段代码不能按预期工作吗？如果将睡眠调用移出unique_lock的范围，则工作正常。
为了澄清:按预期工作：producer()创建存储在data中的新消息，然后由consumer()打印这些消息。当睡眠调用没有注释时会发生什么:不产生输出。我希望每隔1秒产生和打印新的信息。
#include <atomic>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <ratio>
浏览 0提问于2022-10-29得票数 1
回答已采纳
我试图创建一个调用循环中传递的函数的EventTask。
我需要它等待开始，然后标记为完成。
我的问题是，我不知道如何接收来自等待函数的参数，以传递给调用的函数
正如您所看到的，问题在我的taskFunc中，_event.wait应该设置要传递给函数的参数。
class Event
{
public:
Event() : _signalled(false) {}
virtual inline void notify(){
std::unique_lock<std::mutex> lock(_mutex);
_signalled =
浏览 1提问于2019-07-02得票数 0
回答已采纳
1回答
增强线程生产者/消费者意外行为
、、、、
我目前正在编写一个应用程序(使用boost)，它将有一个生产者抓取帧，一个消费者读取帧。我在生产者中添加了一个睡眠语句来模拟抓取帧的时间。我期望消费者等待一个条件变量，并在第一个来自生产者的通知时被唤醒以读取帧。然而，我在日志文件中看到的是消费者(主线程)在等待条件变量，但是生产者在消费者退出读取帧的等待之前经历了几次通知。
这是我的Worker.h
class Worker {
static log4cxx::LoggerPtr m_log;
public:
Worker();
virtual ~Worker();
void start();
void s
浏览 3提问于2012-07-12得票数 0
回答已采纳
2回答
如何正确地进行线程处理？
、、、、
我一直在学习.Net线程，并学习了Threading.Task和Threading.Task.Parallel类。现在，使用ForEach类的Parallel方法，我在一个单独的线程上处理每个对象。但是，我认为ForEach方法等待所有线程在返回之前完成执行。这会导致那些线程在其他线程之前结束而处于空闲状态。我想让这些线程不断地工作。所以这就是我希望做的
我让线程A负责从表中选择记录，然后启动n个工作线程来处理每条记录。
每当工作线程完成其任务时，它都应该要求线程A处理下一条记录。
当将记录分配给工作线程时，如果线程A运行完，它应该返回到数据库并获取更多的记录。我猜这个分配过程必须包装
浏览 2提问于2011-07-08得票数 0
回答已采纳
1回答
在我当前的webapp中，显示可以包含多个可编辑的对象--这些数据要么从服务器获取(然后存储以供将来使用)，要么从本地IndexedDB对象存储中获取。
我已经实现了这一点，它工作得很好。但是，现在我想更进一步--当用户需要与用户一起工作时，获取本地不可用的数据很容易破坏用户的工作时间。
因此，我正在考虑实现一个前瞻性，在用户想要使用这些数据之前获取服务器端数据。它的工作方式
当应用程序启动时，我在与主应用程序共享的IndexedDB中生成了一个监视条目的网络工作者，名为IndexedDB。
用户在可编辑项上盘旋，例如，HTML，abcd1234。
在这个应用程序中，我将这个id添
浏览 2提问于2013-12-20得票数 1
回答已采纳
1回答
我在试着弄明白，在我发出信号之后，我有什么保证。
我认为，使用的基本模式是这个(伪代码)：
消费线程：
Mutex.Enter()
while(variable != ready)
Condvar.Wait()
Mutex.Exit()
生产者线程：
Mutex.Enter()
variable = ready
Condvar.Broadcast()
[Unknown?]
Mutext.Exit()
我的问题是。关于上面代码中的未知点，我得到了什么保证？我仍然持有互斥锁，但是我能知道消费者的状态吗？
从“男人”页面上看，我不清楚制片人在广播/信号之后，以及在释放互斥物
浏览 2提问于2014-10-24得票数 1
我是java并发的新手，我想知道什么时候使用LinkedBlockingQueue。假设有一个上传servlet。可以同时上传。在写入文件时，我们当前使用的是：
// Used for synchronising a small portion of code
private final Object writeLock = new Object();
在实际将文件写入文件系统的代码中，
if (!file.exists()){
synchronized(writeLock){
fileItem.write( file );
}
浏览 3提问于2013-09-26得票数 0
回答已采纳
1回答
我的问题纯粹是概念性的。仅仅是为了更深入地理解线程之间的交流。
在生产者消费者问题上，
有一个生产者线程和一个使用者线程。
生产者线程调用方法产生，使用者线程调用方法消耗。
package ProducerConsumer;
import java.util.LinkedList;
import java.util.Queue;
public class ClassicProducerConsumerExample {
public static void main(String[] args) throws InterruptedException {
浏览 1提问于2019-10-21得票数 1
回答已采纳
1回答
我了解线程处理的基本知识以及死锁是如何发生的。我知道你想按特定的顺序拆下锁，以确保你不会进入圆形行刑队。
我的大脑有问题的是，如何保证这种秩序，以及如何等待和脉冲(脉冲)的帮助。
不要用关于多线程的文章的链接来回答，因为我就是从那里来的。我还在googled上搜索了一下，并想出了这个
在Jon的教程中，方法会生成()并同时使用listlock锁，而且我不知道订单是如何维护的。不管顺序如何，其中一个比另一个强，那么另一个怎么能得到锁呢？它不right...so，最后一个试图锁定的线程处于阻塞状态，直到第一个线程到达脉冲或等待为止。
因此，由于不确定我找了其他文章，所以在上面的那篇文章中，我带着g
浏览 3提问于2013-11-07得票数 0
回答已采纳
我正在开发一个the抓取工具，它应该对被刮掉的数据执行各种操作。
正因为如此，我需要各种不同的GUI来有序地工作，正因为如此，我需要主要的方法来等待，直到每个人都完成了它的目的。
在搜索了一段时间之后，我发现了以下StackOverflow问题，这些问题提供了一些关于如何解决问题的线索，但我无法实现，因为它们与我的情况有些不同：
我知道我可以使用侦听器触发/GUI组件(例如按钮)的代码，但我很难让主线程等待该侦听器唤醒它，而GUI线程的代码(当有一个线程时)由主线程初始化.
这是一段简化的代码，用来演示程序应该如何工作：
public class Main {
/*
浏览 3提问于2012-08-01得票数 0
1回答
如果标题不正确，请原谅，我只是不确定我试图设计的是什么。
假设我有很多任务要做，N。
此外，我有一个最大数量的线程，我可以一次分配，T。
我希望在异步中运行尽可能多的可用线程(直到T)，一旦线程释放，我希望在线程上立即启动一个新任务，直到所有任务都运行完毕。
示例
假设我有10个任务要运行，4个线程可以运行这些任务。当应用程序启动时，4个线程开始运行10个任务中的4个，留下6个剩余任务，当其中一个运行任务完成时，另一个任务立即在一个新线程上运行，剩下5个任务。这种情况一直持续到没有剩馀的任务要执行为止。
问题
我是否可以研究一种设计模式或通用应用程序体系结构来构建这样的任务运行程序？
浏览 0提问于2016-04-13得票数 2
回答已采纳
1回答
我有一个正常的生产者/消费者的工作模式。它有1个生产者和N个消费者。
现在，I##标题##想尝试同时生产和消费，但仍然使用1个生产者和N个使用者线程。
因此，基本上应该像->consume()、->consume()、->consume().
但是现在我有了多个使用者线程，我希望它们在条件下等待()，所以如果在->consume()生成之后发生了另一个消费()，它就会等待。
假设我有1位制片人和4位消费者，它看起来可能是这样的：
produce()->consume()->consume().await->consume().await()->c
浏览 5提问于2016-01-28得票数 1
2回答
PThread互斥锁未按预期工作
、、、、
我使用互斥量来限制某个线程对代码的某些部分的访问，但它似乎允许所有线程“锁定”，而不是锁定一次并阻塞其他线程。下面是我的代码，然后是显示代码不工作的一段输出。
//headers defined, etc
pthread_mutex_t queuemutex = PTHREAD_MUTEX_INITIALIZER;
// other code with various functions
int main(void) {
//unrelated code
threadinformation **threadArray = (threadinformation **)m
浏览 0提问于2013-02-26得票数 2
5回答
我知道std::list并不是线程安全的。在我的应用程序中，线程不断向全局列表中添加元素。另一个线程从列表中获取元素并逐个处理它们。但是，--我不希望处理线程在处理过程中一直锁定列表。
因此，处理线程锁列表、获取元素、解锁列表和处理元素。在处理过程中，其他线程继续向列表中添加元素。一旦处理结束，处理线程再次锁定列表，删除并解锁已处理的元素。
以下是伪代码：
std::list<int> mylist ; /* Global list of integers */
void add_thread(int element) /* Threads adding element to t
浏览 8提问于2014-07-15得票数 1
1回答
我已经创建了一个Windows窗体应用程序，它读取文本文件，重新排列数据，并写入新的文本文件。我注意到，当它运行时，它会以指数级的速度减速。我一直在使用跟踪点、秒表和日期时间来找出为什么每次迭代比上一次迭代花费的时间更长，但我无法弄清楚。我最好的猜测是，这可能与我初始化变量的方式有关。
我不知道这段代码会有多大的帮助，但也许它会让我们了解一下我的问题：
while (cuttedWords.Any())
{
var variable = cuttedWords.TakeWhile(x => x != separator).ToArray();
浏览 4提问于2014-06-06得票数 0
1回答
我有一项任务，需要侦听多个数据源，并对数据进行处理，以便为每输入一条新记录计算一些统计数据(如所有数据的累积和)。
我正在读取带有条件变量的队列的。我想知道这个解决方案是否适用于多个输入场景。
假设我们有两个侦听器线程A& B和一个使用者线程。监听器A调用push函数，获取并释放锁，然后使用条件变量通知使用者。在此期间，监听器B是否有可能在接收到数据时立即接管，从而阻止消费者处理A引入的新数据？当新数据出现时，如何确保使用者逻辑只运行一次，而不管它来自哪个侦听器？
浏览 2提问于2022-09-28得票数 -1
回答已采纳
有人能对这段代码有所了解吗。一步一步地工作？我所理解的是，代码的关键部分被锁定，一次由一个线程访问。
lock (buf)
{
buf.AddRange(ary);
Monitor.Pulse(buf);
}
PS: Msdn将脉冲解释为
脉冲(信号)，PulseAll
向一个或多个等待线程发送信号。信号通知等待线程锁定对象的状态已经更改，并且锁的所有者已经准备好释放锁。等待线程被放置在对象的就绪队列中，以便最终接收对象的锁。一旦线程拥有了锁，它就可以检查对象的新状态，以确定是否已经达到所需的状态。
浏览 2提问于2013-03-04得票数 1
回答已采纳
1回答
我有一个关于condition_variable的问题。
使用下面的代码
#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
#include <condition_variable>
std::condition_variable cv;
std::mutex mut;
int value;
void sleep() {
std::unique_lock<std::mutex> lock(mut);
// sleep
浏览 0提问于2021-05-11得票数 0
我有一个设置，其中有两个不同的线程组执行两个不同的任务(对于那些想知道的人，第一组计算字符串的SHA-256散列，第二组将这些散列与字典中的散列进行比较)。从逻辑上讲，我想要的是创建所有组2线程，让它们等待，然后当每个组1线程计算散列时，所有组2线程都“醒来”，并检查计算出来的散列是否匹配。这是我的第2组线程的代码，使用了一个名为“共享”的计算哈希的共享字典。
private static class Group2Th implements Runnable {
private String dbUser;
private String dbHashedPass;
pr
浏览 1提问于2014-02-20得票数 0
回答已采纳
我在练习这个著名的应用程序，我有一个问题。我发现在这个网站上有4000多个关于这个话题的问题，但是没有一个是与这一点有关的，所以我问这个问题。
以下是简单的代码-
class Resource {
int contents;
boolean available = false;
}
class Producer implements Runnable {
Thread t;
private Resource resource;
public Producer(Resource c) {
resource = c;
t=
浏览 4提问于2014-07-12得票数 0
回答已采纳
我无法理解为什么使用者线程只在生产者编写完10个对象之后才执行。如果我根据javadoc看到线程--只有在同步块完成时才能执行--我不认为在下面的情况下该块是完成的，因为执行是在同步块内的一个循环中进行的。
按java文档通知方法注释
在当前线程放弃此对象的锁之前，唤醒的线程将无法继续。
Runnable consumer = (() -> {
synchronized (BUFFER) {
while(true) {
try {
浏览 0提问于2019-03-28得票数 2
回答已采纳
我们的一个遗留应用程序严重依赖PostThreadMessage()进行线程间通信，因此我们增加了注册表中的USERPostMessageLimit (方式)，超出了正常的10.000。
但是，有关MSDN的文档指出，“此限制应足够大。如果您的应用程序超过此限制，则应重新设计它，以避免消耗太多系统资源。”[1(]
有没有人能告诉我，消耗太多的系统资源到底是如何表现出来的？什么是系统资源？我能以某种方式监控应用程序对系统资源的使用吗？任何信息都将非常有助于决定是否值得花费时间和精力重新设计此应用程序。
浏览 1提问于2008-09-17得票数 4
我想用线程运行我的GUI以避免冻结问题，如何添加线程来查看？或者您有什么一般性的想法来避免GUI冻结问题。
public class Vark {
public static void main(String[] args) {
// Object Creation For the View
VarkView theView = new VarkView();
// Object Creation For the Model
VarkModel theModel = new VarkModel();
/
浏览 3提问于2014-03-18得票数 0
回答已采纳
下面我已经包含了生产者-消费者程序(来自Java -完整的参考指南第九版)，这可能是一个熟悉的例子，线程间通信的许多人。
class Q {
int n;
boolean valueSet = false;
synchronized int get() {
while(!valueSet)
try {
wait();
} catch(InterruptedException e) {
System.out.printl
浏览 4提问于2016-06-08得票数 0
回答已采纳
2回答
我正在研究多线程，并编写了一个基本的生产者/消费者。我与生产者/消费者有两个问题写在下面。1)即使将消费者睡眠时间设置为低于生产者睡眠时间，生产者似乎仍然执行得更快。2)在使用者中，在生产者完成添加到队列的情况下，我重复了代码，但是队列中仍然有元素。有更好的方法来构造代码吗？
#include <iostream>
#include <queue>
#include <mutex>
class App {
private:
std::queue<int> m_data;
bool m_bFinished;
std::mu
浏览 1提问于2020-05-24得票数 4
回答已采纳
1回答
我试图解决多生产者单消费者问题，生产者生成整数，消费者从所有这些整数中生成一个排序列表(使用AVL树)。我应该如何锁定树数据结构？还是没有必要？队列对push和pop操作具有适当的锁定。
void consumer(NaiveQueue<nodeQ> &obj)
{
while(1)
{
nodeQ *temp;
temp=NULL;
temp=obj.pop();
if(temp)
{
cout << "\nRemoved : " << temp->d
浏览 1提问于2014-05-11得票数 0
回答已采纳
1回答
我目前正在学习C++ 11的并发性。我为一个课程写了一段代码。但是，代码没有完成运行。
我的环境：
系统: Windows 10
编译器: mingw-w64x86_64-8.1.0-posix-seh-rt_v6-rev0
更新：
我以为“加入”会结束一条线。感谢那些评论这个问题的好人，我明白“加入”不会“扼杀”这条线。它是在线程执行完成后返回的函数。而且，我的代码中的问题可能与死锁有关。我已经尝试了一些方法来解决这个问题。但是，这两种方法都行不通。
我尝试过的是:添加
if(ConsumerPtr->isConsumerDead()){
break;
浏览 1提问于2019-10-03得票数 0
回答已采纳
1回答
Windows线程的奇数行为
、、、、
我正在结合GTK+，WinAPI和Winsock创建一个图形化的客户机-服务器界面，一个候诊室.nUsers是一个变量，用于确定成功连接的客户端的数量。
在Windows线程中，由以下人员创建：
CreateThread(NULL, 0, action_to_users, NULL, 0, NULL);
我使用“不做任何事”循环，使其冻结直到用户连接。
while(!nUsers);
然而，它从不通过循环，就好像nUsers永远不会变成>0一样。nUsers计数正确连接的客户机数量，因为我经常监视它，并在各种不同的函数中使用它。为了证明我的观点，一些更奇怪的事情发生了。如果我做了循环
浏览 3提问于2017-09-17得票数 0
回答已采纳
在将每个推入队列后，生产者通过conditionVar.notify_one()向消费者发送信号。
但是，使用者在一些随机的推送数(因此发生了随后的notify_one()s)之后醒来，有时21次有时是2198次，等等。在生产者中插入延迟(sleep_for()或delay())没有帮助。
我怎样才能使这个SPSC以锁定的步调运行？
如何将此示例扩展到多个使用者(即SPMC)？
void singleProducerSingleConsumer() {
std::condition_variable conditionVar;
std::mutex mtx;
std::
浏览 12提问于2019-12-19得票数 0
1回答
我有一个代码，我试图运行它，这是提供未支出的输出。
代码：
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ProducerConsumerBlockingQueue {
public static void main(String[] args) {
浏览 1提问于2016-11-20得票数 1
回答已采纳
2回答
我有下面的简单代码，在这些代码中，我从一个以ArrayList表示的队列中放置和提取。
public class EmailService {
private Queue<Email> emailQueue;
private Object lock;
private volatile boolean run;
private Thread thread;
public void sendNotificationEmail(Email email) throws InterruptedException {
emailQue
浏览 3提问于2021-11-03得票数 0
回答已采纳
4回答
我一直在努力解决PC问题，以了解Java同步和线程间通信。使用底部的代码，输出是
Producer produced-0
Producer produced-1
Producer produced-2
Consumer consumed-0
Consumer consumed-1
Consumer consumed-2
Producer produced-3
Producer produced-4
Producer produced-5
Consumer consumed-3
Consumer consumed-4
但是，输出不应该如下所示
Producer produced-0
Consum
浏览 6提问于2017-07-31得票数 3
回答已采纳
4回答
我正在尝试使用两个线程，形成第一个获得输入和第二个处理输入。问题是，我找不到如何在不使用回调的情况下从线程返回一个值--回调不像线程(我认为)，所以任何好的方法都可以这样做和感谢。
Thread t1 = new Thread() {
public void input() {
while (true) {
while (true) {
/*
* get input using Scanner
*/
}
}
}
};
t1.start();
Thread t2 = new Thread() {
pu
浏览 2提问于2014-09-18得票数 1
回答已采纳
可能重复：
我猜不是，我只是想确认一下。意味着使用的两个线程同时使用相同的 std::deque使用std::deque::push_back或push_front。
同样的问题也适用于std::priority_queue和函数std::priority_queue::push和std::priority_queue::pop。
那些容器螺纹安全吗？或者我应该亲自把它编程成线程安全的？
Tnx很多。
浏览 6提问于2010-11-05得票数 12
回答已采纳
1回答
我正在使用音频输出单元来捕获麦克风数据。我得到通知，通过使用kAudioOutputUnit_SetInputCallback属性设置的回调来读取数据，而在回调中，我通过调用AudioUnitRender()读取数据。
最终，我将根据通过分析这些数据提取的一些信息来更新我的应用程序的用户界面。因此，在某个阶段，我需要在主队列上执行一个dispatch_async。这一分析比较耗时，并且比我从AudioUnitRender()获得的分析要大得多，因此负载是突发的。
我的问题是:在实现输入回调本身时，哪些操作被认为是可以接受的？我已经找到了很多对呈现回调进行严格限制的源(没有内存分配、没有i/o、
浏览 3提问于2015-04-20得票数 1
2回答
我最近遇到了一个需求，其中需要多线程应用程序，其线程以不同的速度运行。然后问题就变成了，因为我还在学习多线程:我们给出了一个场景来将事情放在正确的角度：
假设第一线程以100赫兹“实时”运行，第二线程以10赫兹运行。
并且说第一个线程向第二个线程提供数据"myData“。
如何将myData提供给第二个线程，这是一种常见的做法，即只阅读第一个线程中提供的任何内容，或者需要某种抽取来降低速率。
myData是否需要某种具有锁定机制的单例。虽然myData不是共享的，而是由第一个线程更新并在第二个线程中使用。
相反的情况如何，当一个线程中使用的数据需要在另一个线程中以更高的速率
浏览 2提问于2015-10-08得票数 0
回答已采纳
1回答
让线程本地队列具有计数器
、、、、
我有四个线程，它们有自己的私有队列和私有的'int计数‘成员，每当从程序线程生成任务时，都应该将其排队到线程的队列，其中线程中的’int计数‘最小。
每当任务被推入队列时，当任务从队列中弹出时，私有'int计数‘应该增加1，而私有'int计数’应该减少1。
因此，“int计数”是关于任务推送、pop操作的动态更改，而程序线程将将任务分派给队列，其计数最低(或第一个零)。。
这是程序的基本逻辑。
我在linux多线程库中使用c++编程语言，实现多速率同步数据流范例。
请您给出一些实现这一逻辑的编码思想。即。1.初始化所有私有int队列计数器=0
2.counter++当任
浏览 3提问于2013-01-09得票数 1
2回答
生产者-消费者代码
、、、
我脑子里的想法是：
📷
我不确定是否需要消费者和生产者中的index变量。
此外，我想知道它是否可以像这样(它似乎有效)，还是只是一些愚蠢的工作代码。它是否更聪明/更有效率？把可读性留给我。
我的代码将使用POSIX信号量mutex来访问CS (它是从共享的单词缓冲区写入/读取)。
full和empty用于指示缓冲区是满的，还是空的，这样，如果缓冲区已满，我们就不会写单词(如果这样做，在使用者读取缓冲区之前，我们将覆盖第一个单词)。类似地，我们不希望从任何空缓冲区中读取！
当生产者完成时，它设置一个共享标志(在0中初始化)。但是，在消费者端，我不仅要检查标志，还要检查full和empty的值。
浏览 0提问于2014-12-28得票数 3
回答已采纳
1回答
unix中的线程通信
、、、、
我已经编写了一个程序，其中主线程创建一个线程并在辅助线程必须工作时发送一个事件，这在windows上非常好，但是当将其移植到*nix时，很难实现相同的工作。
让我解释一下，请考虑以下几点
/* thread2 function */
thread_function_call()
{
/* be a consumer */
pthread_exit();
}
/* main function */
main()
{
/* create a thread */
pthread_create();
while(1)
{
浏览 0提问于2011-02-22得票数 0
问题陈述：标识无限整数流中的两个连续整数，其中这些整数由多个生产者产生，但是当相同的数字再次重复时，单个消费者会发出警报。
我有多个Producers和一个Consumer。如果我将“消费者”提交到相同的ExecutorService，则“消费者”没有启动。但是，如果我在单独的线程中运行使用者，消费者线程就会像预期的那样启动。
代码：
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.locks.Reentr
浏览 3提问于2016-06-13得票数 2
回答已采纳
我看到了许多使用BlockingCollection<T>实现的生产者/消费者队列的结果是独立的，例如，每个结果都可以独立地并行使用。例如，这里生成一个计算平方根，使用者获取每个结果来更新UI。
我想知道，如果消费者不能独立地处理生产者计算的每一个结果，是否可以避免显式锁定。我创建了一个演示示例，在处理每个结果时必须考虑到以前处理的结果，以便向数据网格插入一行或更新现有的数据网格；对于一些小数据，它似乎正常工作。
我的问题是：
是否可以避免显式锁定？
如何将使用者和生产者封装在单个对象中，例如ProducerConsumerQueue，它实际上是一个生产者队列。
目前，我使用一个单
浏览 0提问于2017-04-18得票数 3
回答已采纳
1回答
我正在处理的当前项目要求我实现一种方法，以有效地将一组对象从一个线程(持续运行)传递到主线程。当前的设置如下所示。
我有一个主线程，它创建一个新线程。这个新线程连续运行，并调用一个基于计时器的方法。此方法从在线源获取一组消息，并将其组织在TreeSet中。
然后，需要将此TreeSet传递回主线程，以便可以独立于定期计时器处理它包含的消息。
为了获得更好的参考，我的代码如下所示
// Called by the main thread on start.
void StartProcesses()
{
if(this.IsWindowing)
{
retur
浏览 4提问于2013-06-17得票数 0
我正在阅读MSDN上的AutoResetEvent文档，下面的警告让我有点困扰。
“重要:对Set方法的每一次调用都不能保证释放线程。如果两个调用太近，以致第二个调用发生在线程释放之前，则只释放一个线程。就好像没有发生第二个调用一样。此外，如果在没有线程等待且AutoResetEvent已经发出信号时调用Set，则调用无效。”
但是，这个警告基本上消除了使用这样的线程同步技术的原因。举个例子，我有一份能保住工作的清单。而且只有一个生产者将增加就业机会。我有消费者(不止一个)，等着从名单上得到这份工作。就像这样..。
制片人：
void AddJob(Job j)
{
lock(qLoc
浏览 4提问于2012-02-29得票数 2
回答已采纳
4回答
具有细粒度锁的线程安全链接列表
、、、、
在一个程序中，我有一个M类：
class M{
/*
very big immutable fields
*/
int status;
};
我需要一个M型对象的链接列表。
有三种类型的线程正在访问列表：
生产者:将对象生成并追加到列表的末尾。所有新生成的对象都有status=NEW。(操作时间= O(1))
使用者:在列表的开头使用对象。如果一个对象有status=CONSUMER_ID，它就可以由它消费。每个使用者都将第一项保留在它可以使用的链接列表中，这样消费就可以被(摊销？)O(1)(见下文注)。
析构函数:当有一个通知说对象已正确使用时
浏览 5提问于2011-10-28得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
