如何在java中解决"1生产者2消费者“的问题？
在Java中解决"1生产者2消费者"问题可以使用多线程和线程间通信的机制。以下是一种常见的解决方案：
- 创建一个共享的缓冲区，用于生产者和消费者之间的数据交换。
- 使用互斥锁（如synchronized关键字）来保护共享缓冲区的访问，确保同一时间只有一个线程可以访问缓冲区。
- 使用条件变量（如wait()和notifyAll()方法）来实现生产者和消费者之间的协调。
具体步骤如下：
- 定义一个缓冲区类，包含一个用于存储数据的队列和相应的操作方法（如put()和get()）。
- 在缓冲区类中使用synchronized关键字来保护put()和get()方法，确保同一时间只有一个线程可以访问缓冲区。
- 在put()方法中，如果队列已满，则使用wait()方法使当前线程等待，直到有空间可用。当有空间可用时，将数据放入队列，并使用notifyAll()方法唤醒等待的线程。
- 在get()方法中，如果队列为空，则使用wait()方法使当前线程等待，直到有数据可用。当有数据可用时，从队列中取出数据，并使用notifyAll()方法唤醒等待的线程。
- 创建一个生产者类，实例化缓冲区对象，并调用put()方法将数据放入缓冲区。
- 创建两个消费者类，实例化缓冲区对象，并调用get()方法从缓冲区中取出数据。
这样，生产者和消费者就可以通过共享的缓冲区进行数据交换，通过互斥锁和条件变量实现线程间的同步和协调。
推荐的腾讯云相关产品：腾讯云服务器（https://cloud.tencent.com/product/cvm）和腾讯云容器服务（https://cloud.tencent.com/product/ccs）。
相关·内容
我正在学习Java的锁和条件，并且已经实现了生产者和消费者的code.Idea是有一个生产者和N消费者。但是，当我运行代码时，总是有一个使用者线程读取。
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ProdConsumer {
int
浏览 7提问于2022-09-02得票数 1
我对卡夫卡很陌生。我有以下架构：
1) 2 servers runing application logics and database, can I write kafka producer on these servers wrapped with docker container ?
2) 1 server reserved for kafka broker and zookeeper
3) 1 sever reserved for kafka comsumer
我很困惑
1) whether I can run kafka producer, broker and consumer
浏览 6提问于2015-11-02得票数 0
回答已采纳
3回答
在下面的代码中，当我执行producercon类时，有时执行会阻塞，看起来像是死锁。但是如果我使get_flag ()同步，那么就不会有这样的问题。
我不明白怎么会有问题。flag可以是true也可以是false，因此producer或consumer中只有一个会进入if语句。在其中一个进入if之后，它将进入带有对象r的监视器(两者都是用相同的对象引用初始化的)。唯一可能发生的问题是，由increment_decrement ()函数调用修改的r对象，同时get_flag ()读取标志，但即使在那时，它也不会在该迭代中进入if，但它将在下一次迭代中进入if块，并且即使第一线程没有离开监视器，它
浏览 0提问于2011-12-10得票数 4
回答已采纳
我很难将带有虚假等待的老式等待通知转换为java.util.concurrent API。
第一个问题:根据问题，使用什么，未来、CountdownLatch还是CyclicBarrier
第二个问题:如何使用它？因为在我看过的所有示例中，都是将单个异步方法转换为同步方法，这不是问题
第三:在我的例子中，out Future任务的get方法的最佳选择是CountDownLatch还是CyclicBarrier，因为我没有多线程，而只有2个线程。
我的异步代码
主类：
public static void main(String[] args) throws InterruptedExcepti
浏览 0提问于2015-01-20得票数 1
3回答
我想创建一个线程，它在队列为空时将值放入队列，并在队列不为空时等待该条件。下面是我尝试使用的代码，但它打印出来
Adding new
Taking Value 1
Taking Value 2
Taking Value 3
Taking Value 4
所以它只工作一次。有什么问题吗？
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class SO {
public String test;
public String[]
浏览 1提问于2010-02-28得票数 1
回答已采纳
1回答
带有条件变量的Java互斥关联
、、、、
Java中的每个条件变量(wait()、notify())都与单个互斥(同步)相关联。
我曾说过(在Java中)，每个互斥对象也与一个条件变量相关联，这是一个比p线程的cond变量和互斥变量更低效率的实现。然而，我无法理解这一条。那是什么意思？Java与C/C++线程在这个问题上有什么不同？
浏览 3提问于2016-01-31得票数 2
回答已采纳
我是Spring集成的新手；如果我没理解错的话，spring集成有3个关键角色；
1个出版商
2个订阅者
3通道。
我能理解使用DB/文件系统作为队列的发布者和订阅者框架。spring集成队列驻留在哪里？如果发布者和订阅者本身是单独进程，它们如何共享通道？通道是否可供发布者进程和订阅者进程访问，因为它们运行在相同的JVM中？
这是否意味着，如果publisher运行在一台机器上，而subscriber运行在另一台机器上，我们就不能使用Spring集成吗？
浏览 0提问于2017-03-10得票数 1
我正在开发一个用Java编写的多线程程序，它使用共享数组在线程之间传递数据。它是在Netbeans 6.7.1中开发的。
其中一个线程似乎只在其中放置了断点时才能工作，它在哪里并不重要。
在没有断点的调试模式下运行与在release中运行的行为相同-预期的输出永远不会到达。
我不知道问题发生在哪里，因为当添加断点并按下continue时，它就像预期的那样工作。
如何缩小发生此问题的位置/原因？
示例代码：
result = utils.isBufferFull(AudioDuplex.voiceArray);
if(result == true) {
System.out.printl
浏览 0提问于2010-02-24得票数 0
回答已采纳
我找到了下一个代码：
public static void main(String args[]) {
Producer producer = new Producer();
producer.start();
new Consumer(producer).start();
}
}
class Producer extends Thread {
static final int MAXQUEUE = 5;
private Vector<String> messages = new Vector<Strin
浏览 0提问于2012-04-05得票数 0
回答已采纳
我在实践中阅读Java并发时，遇到了以下代码片段。清单12.5 https://jcip.net/listings/PutTakeTest.java // Listing 12.5. Producer-consumer test program for BoundedBuffer.
package net.jcip.examples;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import junit.framework.TestCase;
/**
* PutTakeTest
* <
浏览 19提问于2020-09-27得票数 0
回答已采纳
1回答
在下面的程序中，程序不知何故没有结束。当我调试时，在检查lock变量时显示锁是由生产者线程持有的，如下所示
java.util.concurrent.locks.ReentrantLock@55584367Locked按线程池-1-线程-1 java.util.concurrent.locks.ReentrantLock$NonfairSync@5b9fb7bcState = 8，空队列
public class LocksTest {
public static void main(String[] args) {
List<String> co
浏览 1提问于2018-07-23得票数 0
2回答
这是我的场景。该程序采用发布者/订阅者方法开发。在生产者和消费者部分有两个主题(topic1，topic2)。我需要在生产者程序中获得消费者对接收到的topic1的确认，这样当确认状态为真时，生产者程序将不得不在topic2上发送消息。
有谷歌链接建议session.CLIENT_ACKNOWLEDGE在消费者。但我需要将确认状态返回给producer，以便进一步处理。
浏览 3提问于2013-01-22得票数 1
3回答
假设有1个生产者P和2个消费者C1和C2。并且有2个队列Q1和Q2，它们都具有特定的容量。
P将生成项目，并将其交替放入Q1和Q2中。商品是为特定消费者生产的，不能被其他消费者消费。如何在java语言中实现以下功能:在启动3个线程后，如果Q1为空，线程C1将被阻塞，直到Q1中出现异常时才会通知它。Q2也是如此。当Q1和Q2都已满时，P将被阻塞，直到当Q1或Q2未满时被通知。
我在考虑使用BlockingQueue，当消费者的队列为空时，它会阻塞消费者。但问题是，当其中一个队列已满时，生产者将被阻塞。Java中有没有什么数据结构可以用来解决这个问题？
更新
我自己已经有了一个解决方案，但我不确定
浏览 3提问于2013-05-31得票数 8
我的应用程序负载很重，我在下面的日志中
sudo -u tomcat jstack <java_process_id>
下面的线程正在消耗卡夫卡的信息，并且被卡夫卡卡住了。由于这个线程处于等待状态，因此不再消耗卡夫卡消息。
"StreamThread-3" #91 daemon prio=5 os_prio=0 tid=0x00007f9b5c606000 nid=0x1e4d waiting on condition [0x00007f9b506c5000]
java.lang.Thread.State: WAITING (parking)
at s
浏览 0提问于2018-03-18得票数 0
6回答
我正在看一个关于Java多线程的视频教程。介绍了用Java实现著名的“生产者-消费者”问题。
它使用wait()和notifyAll()来确保生产者线程和消费者线程之间的正确通信。
这位导师故意创建了几个生产者线程，而只有一个消费者线程，但他留下了一个未回答的问题：“最好是生产者线程和消费者线程的数量相等，如果生产者线程比消费者线程多，就会有问题”。
然而，他没有具体说明问题是什么。我个人认为这只是一种篮子满了的情况。专家们能在这方面提供帮助吗？谢谢。
浏览 2提问于2013-04-05得票数 5
回答已采纳
1回答
我熟悉Java生产者和消费者模型。我有一个为另一个进程生成地图的过程来分析。我之前使用生产者和消费者模型在java中实现了这个模型。我也在Scala上做同样的尝试。本教程讨论的是参与者，即完成此过程的消息传递框架。但有什么很好的例子可以解释这些问题吗？在Scala中可以像在java中一样控制线程数吗？
浏览 2提问于2014-01-09得票数 1
回答已采纳
我们正在从IBM MQ迁移到Amazon MQ，至少我们愿意这样做。问题在于，与IBM MQ相比，Amazon MQ在使用JMS producer将较大的消息放入队列时的性能较差。
所有消息都是持久的，系统关于IBM MQ是高可用性的，Amazon MQ是多AZ的。
如果我们将这个大小的XML文件放到IBM MQ (2个cpu和8 8GB HA实例)中，我们会得到这样的性能：
256 KB = 15ms
4,6 MB = 125ms
9,3 MB = 141ms
18,7 MB = 218ms
37,4 MB = 628ms
74,8 MB = 1463ms
如果我们将相同的文件放在Amaz
浏览 3提问于2020-03-26得票数 1
2回答
通常存在的话题会帮助我克服一个问题，但现在我发现自己被困住了。
我想在Java中使用并发性来实现Prod/Cons。不使用现有的API，因为这是为了学习目的。
我的生产者阻止消费者使用来自队列(Holder)的消息，但我希望生产者和消费者同时使用队列。
您可以运行我的示例，您将看到，当生产者添加时，使用者等待锁。但我希望消费者在添加信息后立即做好自己的工作，而不是当制片人告诉他时。
我感到惊讶的是，我发现搜索P/C模式的所有例子都是我的(生产者阻止消费者，这对我来说没有意义)
import java.util.LinkedList;
import java.util.Queue;
import
浏览 3提问于2015-03-04得票数 3
1回答
我试图用多线程来解决Java中的生产者/消费者问题，但是我一直陷入僵局，我不知道为什么。
BoundedBuffer.java
public class BoundedBuffer {
private final int[] buffer;
private final int N;
private int in = 0;
private int out = 0;
private int itemCount = 0;
public BoundedBuffer(int size) {
N = size + 1;
b
浏览 2提问于2015-09-28得票数 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
3回答
我有两个带有全局堆栈变量的线程。Thread1接收传入的消息并放入堆栈中。线程2检查堆栈中是否有接收到的消息/s并对其进行处理。
但是，当我运行我的程序时，我会收到这样的异常：
java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 1
java.util.EmptyStackException
at java.util.Stack.peek(Unknown Source)
at java.util.Stack.pop(Unknown
当我不使用线程时，不会出现这些异常。但是，当我把我的程
浏览 6提问于2014-07-15得票数 1
回答已采纳
1回答
首先让我告诉你我已经安排好了。
持久和持久的队列和交换。
手动攻击。
在弹簧靴中使用兔子in。
SimpleMessageListenerContainer的并发使用者为10，最大使用者为50。
问题是，我正在发送消息m1，然后发送m2。m1需要时间来处理。m2过程在m1之前完成。在这里，对于m1和m2，传递标记与1相同。因此，消息m2在m1之前被添加，而当m1被添加时，我得到了未知的传递标记1异常。
令人惊讶的是，生产者也收到了消息m1 ack。但问题是m1在RMQ管理控制台中很长一段时间都处于未加标记状态。
在RMQ中，我可以在m2之前对m1进行编程吗？我知道这两条
浏览 0提问于2018-05-28得票数 0
回答已采纳
1回答
我正在尝试写一个生产者消费者代码。下面是我编写的原始代码。
Stack<Integer> buffer = new Stack<>();
volatile int i = 1;
class Consumer implements Runnable {
@Override
public void run() {
while(true){
synchronized (buffer) {
System.out.println("Consumer taking lock : &#
浏览 1提问于2018-12-21得票数 0
我有两个线程，两个线程都访问一个向量。t1添加一个随机数，而t2删除并打印第一个数字。下面是代码和输出。t2似乎只执行了一次(在t1启动之前)，并且永远终止。我是不是漏掉了什么？(PS:也用ArrayList测试)
import java.util.Random;
import java.util.Vector;
public class Main {
public static Vector<Integer> list1 = new Vector<Integer>();
public static void main(String[] args) throws
浏览 3提问于2015-10-27得票数 5
回答已采纳
5回答
这个问题与Java的最新版本有关。
30个生产者线程将字符串推送到抽象队列。一个写入线程从同一个队列弹出，并将字符串写入驻留在5400 rpm HDD RAID数组上的文件。数据以大约111 MBps的速度推送，弹出/写入速率约为80 MBps。该程序运行5600秒，足以使176 GB的数据在队列中积累。另一方面，我被限制在总共64 of的主存上。
我的问题是:我应该使用什么样的队列？
到目前为止我已经尝试过了。
1) ArrayBlockingQueue。这个有界队列的问题是，无论数组的初始大小如何，一旦它填满，我总是会出现活性问题。实际上，在程序启动几秒钟后，top只报告一个活动线程。分析
浏览 5提问于2013-10-05得票数 3
回答已采纳
1回答
Redis使用者无法使用特定事件
、、、、
我在一个spring boot项目中有一个生产者，它向同一个redis消费者组产生两个事件，另一个消费者(另一个spring boot项目)消费相同的事件。redis使用者只能使用一种类型的事件。在使用第二种类型的事件时，我看到以下异常：
在consumer spring应用程序中发现异常:-
2021-01-06 19:14:22,580 ERROR [SimpleAsyncTaskExecutor-1] DefaultStreamMessageListenerContainer$LoggingErrorHandler: Unexpected error occurred in schedu
浏览 4提问于2021-01-06得票数 1
3回答
我试图解决这个问题，但它被证明是困难的。
我有两个线程，一个是生产者，另一个是消费者。都在不同的类中。这两个线程独立运行。生产者汇集了大约8-12个文件夹用于输入。然后，它会同时翻译所有文件，并将其放入名为“readyToLoad”的共享文件夹中。一旦生产者线程完成，消费者线程现在进入'readyToLoad‘文件夹，并开始处理翻译后的文档。
现在的问题是，当消费者正在处理翻译的文档时，它不允许生产者在'readyToLoad‘文件夹中放入更多的翻译文件。
我的问题是，我如何防止消费者锁定'readyToLoad‘文件夹？我该如何处理这种情况？
很抱歉我的文本很长，但我
浏览 0提问于2013-07-19得票数 1
我必须开发一个类似于java中生产者-消费者问题的应用程序。
然而，我对java了解不多，我有几个问题。
生产者和消费者都是不同的线程，它们都需要访问相同的缓冲区。如果它们都是不同的类(要么扩展了线程类，要么实现了runnable接口)，我该如何编写代码让它们使用完全相同的buffer (这个假定的buffer是一个特定对象的数组)？
我还想阅读一些关于整体架构的建议，以及我应该如何实现它们。我需要对它们进行编码，这样两个线程不会同时使用相同的缓冲区位置，两个生产者线程不会在同一时间以完全相同的值插入，生产者不能在已经填满的缓冲区中插入新项，并且当缓冲区为空时任何消费者都不应该使用。
在这个例
浏览 0提问于2011-09-26得票数 3
回答已采纳
我经常使用(多)生产者-队列-消费者设计模式，但我不知道如何获得操作的结果。
我有3个生产者P1，P2，P3，它们产生一个消息IMessage；这个消息是在一个同步队列中发送的，并在Cosumer中详细说明。
使用者C如何告诉生产者(P1、P2或P3)请求已完成并给出结果？
浏览 2提问于2013-02-05得票数 0
回答已采纳
1回答
Java:多线程
、、
/*哪里出了问题，每次生产者只执行和消费者不消费任何东西。请解释一下这段代码出了什么问题。
我的预期结果是:生产者生产1种产品，那么消费者就必须消费该产品*/
import java.util.ArrayList;
public class ConsumerAndProducerMain
{
public static void main(String[] args) throws InterruptedException
{
int MAX_SIZE = 10;
ArrayList<Integer> list = new Arra
浏览 3提问于2014-11-20得票数 0
回答已采纳
2回答
我正在从事一个使用PubSub( GCP )的项目，我的问题并不是针对GCP的，而是更多地涉及到体系结构模式(我习惯于静态类型化语言，我很难找到如何以正确的方式做到这一点)。
我正在处理的服务是用go编写的，我想要的(至少对我来说，这似乎是正确的方法)是强制使用者和生产者使用相同的消息格式(在编译时商定模式)。现在，这两个部分是完全独立的，所以我们在两个地方指定了消息格式(这确实让我感到烦恼)。
一开始，我认为消费者应该拥有信息格式(不要认为我是这种架构的新手)，和同事讨论了一下，然后做了一些阅读，我同意这会打破模式，因为生产者会了解消费者，当你有多个消费者时，也会出现一个问题。
我的下一个想
浏览 0提问于2020-05-06得票数 1
回答已采纳
我目前有一个java程序，它运行一个存储过程，一次调用一个数组列表中的一条记录，该列表循环直到所有记录都被处理完。目前，从存储过程调用返回每条记录大约需要8秒。在完成调用之后，它从SP获取XML消息，并在代码中继续将该消息写入队列，然后更新数据库中的一个字段以将该记录标记为已处理。 我想要做的是让x个线程一次命中/调用存储过程，以加快完整数组列表的处理时间，并像现在一样继续执行其他步骤。数组列表可以是从几百条记录到4000条以上记录的任何位置。 有没有办法在调用之后仍然通过相同的过程，但添加多线程，以一次多次命中SP，而不会出现问题？我只写了很短的一段时间，所以请耐心等待，谢谢！ publi
浏览 25提问于2019-01-10得票数 0
我有一个想要彼此交流的人的HashMap，如下所示： {zidane=[rooney, rooney, rooney, scholes, rooney], rooney=[scholes, messi, scholes], scholes=[ronaldo], ronaldo=[rooney, messi, scholes], messi=[zidane]} 在这里，密钥中的每个人都有自己的线程，在这些线程中，他们将向列表中的每个人发送一条消息并接收响应。 public class Master {
public Map callsMap = new HashMap<Strin
浏览 52提问于2020-06-15得票数 0
我正在使用一位同事编写的CXF-Interceptor将第三方was服务所需的soap头添加到由xsl文件创建的apache camel消息的soap信封中。拦截器对我的同事来说工作正常，但在我的路线上却失败了。我直接从他的路由复制了我的端点，所以我不认为这是问题所在。我问我的同事，他从来没有见过这样的事情。
我的路线是：
<to uri="bean:applicationName?method=setBodyToBlankXML" />
<to uri="xslt:xsl/applicationName-thirdPartyWebserviceOpe
浏览 1提问于2015-02-07得票数 1
1回答
我的两根线，生产和消费，不工作很好。当我运行这段代码时，控制台一个一个地打印“产生”和“消费”。然后，它停止了，程序仍然是running>。
class BufferMutex {
private char [] buffer;
private int count = 0, in = 0, out = 0;
private ReentrantLock mutex = new ReentrantLock();
private Condition okProduce = mutex.newCondition();
private Condition
浏览 3提问于2022-05-18得票数 0
回答已采纳
代理在n生产者和m消费者之间工作。ith生产者，生产s_i (像糖果一样的产品)糖果和jth消费者在今年消费(像吃！) b_j糖果。每销售一颗糖果，代理商就会得到1美元的奖励。对于某些问题，定义了一条严格的规则，即生产商应该向任何生产商销售糖果，并且它们之间的距离不大于100 KM (KM)。如果我们有所有生产者-消费者对的列表，它们之间的距离小于100 KM，那么以下哪种算法对于寻找最大收益是愚蠢的？(假设s_i和b_j可能会变得非常大)。
1) Maximal Matching
2) Dynamic Programming
3) Maximum Flow
4) 1 , 3
一位用户
浏览 1提问于2015-02-19得票数 2
我不知道为什么生产者发送的数据没有到达消费者手中。我正在使用cloudera虚拟机。我正在尝试编写简单的生产者消费者，其中生产者使用Kafka，消费者使用spark streaming。
scala中的生产者代码：
import java.util.Properties
import org.apache.kafka.clients.producer._
object kafkaProducer {
def main(args: Array[String]) {
val props = new Properties()
props.put("bootstrap.
浏览 0提问于2017-11-19得票数 1
2回答
大家好，
我们使用Spring与使用wlfullclient.jar的Weblogic JMS服务器集成。每隔一段时间，jmsListenerthreads就会卡住。我们已经观察到在刷新连接时会发生这种情况。
使用的版本: wlfullClient.jar : 10.0.1 Spring : 3.0.3
两个阻塞线程的堆栈跟踪：
Name: jmsListenerContainer-1770
State: WAITING on weblogic.jms.client.JMSSession@35c0fb37
Total blocked: 3,681 Total waited: 3,66
浏览 2提问于2011-01-19得票数 1
回答已采纳
1回答
我遇到了生产者消费者的情况，其中我使用了arrayblockingqueue。如果消费者线程出现异常，如何停止生产者线程。我需要producer停止等待队列为空。我诱导了一个强制的运行时异常。但是程序不会退出。生产者一直在等待队列为空。有人能帮帮忙吗？ public class ServiceClass implements Runnable{
private final static BlockingQueue<Integer> processQueue = new ArrayBlockingQueue<>(10);
private static
浏览 15提问于2019-09-28得票数 1
回答已采纳
首先，感谢你的好榜样。
我试着遵循 ContinuousCapture.java示例，并生成了下面的程序。
1)
我试图将图像显示到本机层的TextureView中，获取其ANativeWwindow引用，并使用ANative锁和解锁lock方法获取BufferQueue并填充数据。
Ie：
ANativeWindow_lock(*window, &buffer, NULL)
ANativeWindow_unlockAndPost(*window);
2)
同时，我希望从该Surface检索数据并将其传递给编码器。或者，把它展示到另一个表面。
作为第一步，我创建了下面的类，它将Egl
浏览 0提问于2015-11-20得票数 1
1回答
这个问题在我的脑海里已经大约一年了。事实上，在无障碍和非阻塞方面有什么区别吗？当我们在代码中调用阻塞部分时，它就变成了阻塞，这是同步的，同时也不会是非阻塞的。
如果我们要创建除主线程之外的另一个线程来进行异步编程，并且必须返回一些值，那么我们必须在java中定义join()方法，而join()是阻塞操作，那么它实际上是异步的吗？
我需要知道以下问题的答案
如果阻塞类似于同步，那么异步和非阻塞之间有什么区别。应该类似吗？如果不是，那为什么？
反应式编程，它是非阻塞的，完全异步编程吗？
浏览 1提问于2020-09-23得票数 9
回答已采纳
3回答
我有两个线程：
线程1正在从循环中的web服务获取XML。
线程2正在解析线程1获取的XML，并将其显示在UI中。
请告诉我，在线程1检索XML数据时，将XML数据从线程1传递到线程2的最佳方式是什么？
线程1正在获取XML，然后线程2正在使用它。
为此，我创建了一个循环链表，线程1将它的XML放在链表中，线程2获取它的XML并将其从列表中删除，它工作得很好。
请告诉我有没有比我使用的更好的方法。
浏览 1提问于2010-12-01得票数 1
回答已采纳
3回答
实施生产者消费模式
、、、、
我正在尝试编写一个将邮件放入队列中的邮件实用程序，它稍后会被使用者线程所使用。
我试图实现一个典型的生产者-消费者模式，但有些地方出错了。
我刚刚写了一个骨架，这个骨架不像预期的那样工作。
MailProducer.java
public class MailProducer implements Callable<Void>
{
@Override
public Void call() throws Exception
{
System.out.println("inside mail Producer");
System.out.printl
浏览 7提问于2011-10-24得票数 3
回答已采纳
我有一个关于2个代理的3个分区的主题。(Kafka版本: 0.8.1)
使用不同的用户guid (例如: FC42B34DD7658503E040970A2C437358)作为分区键批量添加消息。(约10k条消息)
加载消息时，我有一个正在运行的使用者(consumer1)，它开始很好地处理消息。
然后，我使用相同的消费者组id启动了另一个消费者(consumer2)。
我注意到的是，consumer1停止处理消息，而consumer2开始处理所有消息。
当我停止consumer2时，consumer1接管并恢复消息处理。
我希望两个消费者都能分担负载。
有什么线索可能是问题所在吗？谢谢。
浏览 0提问于2015-03-28得票数 1
3回答
我编写了一个简单的消费者生产者问题，它有一个阻塞队列，它有多个生产者和多个消费者在队列中获取和放置整数。但是，当我尝试测试它时，结果并不如预期的那样，例如队列的大小不正确。我不认为消费者和生产者的规模是同步的。此外，我让生产者和消费者都睡了2秒，但是在测试的时候，每两秒它就会打印出两个生产者和两个消费者的结果。有人知道我做错了什么吗？也许我的思路搞错了？我用另一种方式来评论，但结果仍然是错误的。
结果：
run:
Producing 425 Thread-0 size left 0
Consuming 890 Thread-3 size left 0
Consuming 425
浏览 9提问于2012-10-09得票数 3
回答已采纳
1回答
我已经实现了一个生产者-消费者的信号量实现。
我期待着您的代码评审意见。
谢谢。
package ProducerConsumer.Semaphore;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class SemaphoreMain {
public stati
浏览 0提问于2020-07-29得票数 2
1回答
生产者-消费者模型
、、、
我试图模拟生产者-消费者的多线程模型。
我们假定有三条规则需要遵守：
当桶中满是products.Consumer时，生产者不能将产品添加到桶中，当桶为empty.Producing时，无法从桶中获取产品，并且不能同时进行消费。换句话说，这两个操作是异步的。
我现在拥有的是：
a int varible用于将产品数量存储在存储桶中的变量存储桶容量的const int变量，在我的代码中值为5。是互斥量的int变量，初始值为1<code>H 217<//code><code>H 118</code>a vector<HANDLE>用于挂起
浏览 0提问于2020-04-28得票数 1
最近，我学习了Java线程通信中的通知和等待，并尝试编写经典的消费者和生产者问题，在我的代码中，我实际上有4个线程，其中2个是消费者，另外2个是生产者。
package producer_consumer;
class Shared {
private volatile boolean writable = true;
public Character character = 'A';
public synchronized void produceChar(Character c) {
while (!writable) {
浏览 0提问于2017-05-26得票数 1
我使用map_async处理返回大量数据的进程。普通的map_async会将数据存储在内存中，然后在处理完所有内容后返回。为了解决这个问题，我使用了下面的生成器方法：
然而，这并没有充分利用多线程(例如，如果您有29个线程完成，1个线程挂起，那么在每个人都完成之前，它不会启动下一批作业)。有没有办法拥有map_async，或者是否存在一个类似的函数，它会在每个线程完成时将其返回发送到回调函数？
浏览 1提问于2013-04-12得票数 1
我正在开发一个使用Java开发的基于多线程的Web应用程序。
我在该应用程序中有两个线程，类似于生产者和消费者，其中一个线程不断地从第三方API (套接字连接)读取数据，并将其更新到缓存中。另一个线程(使用者)不断尝试从缓存中读取数据。
我的问题是，当数据发生变化时，是否有任何方法可以提高使用者线程的性能(我的意思是它只从缓存中读取数据)。
浏览 2提问于2012-09-17得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
