问题在《一个java生产者消费者代码的问题》，解答一下，只解释原因，其他不考虑。
作者要的是一个生产者生成，接着必须有一个消费者消费，那这不是需要单线程吗？或者使用1个大小的阻塞队列。所以只谈论问题本身，不谈论好不好。
具体代码：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//生产/消费者模式
public class Basket {
Lock lock = new ReentrantLock();
// 产生Condition对象
Condition produced = lock.newCondition();
Condition consumed = lock.newCondition();
boolean available = false;
public void produce() throws InterruptedException {
lock.lock();
try {
if (available) {
produced.await(); // 放弃lock进入睡眠
}
System.out.println("Apple produced.");
available = true;
consumed.signal(); // 发信号唤醒等待这个Condition的线程
} finally {
lock.unlock();
}
}
public void consume() throws InterruptedException {
lock.lock();
try {
if (!available) {
consumed.await(); // 放弃lock进入睡眠
}
/* 吃苹果 */
System.out.println("Apple consumed.");
available = false;
produced.signal(); // 发信号唤醒等待这个Condition的线程
} finally {
lock.unlock();
}
}
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//测试用类
public class ConditionTester {
public static void main(String[] args) throws InterruptedException {
final Basket basket = new Basket();
// 定义一个producer
Runnable producer = new Runnable() {
public void run() {
try {
basket.produce();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
};
// 定义一个consumer
Runnable consumer = new Runnable() {
public void run() {
try {
basket.consume();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
};
// 各产生10个consumer和producer
ExecutorService service = Executors.newCachedThreadPool();
for (int i = 0; i < 4; i++)
service.submit(consumer);
Thread.sleep(2000 * 2);
for (int i = 0; i < 4; i++)
service.submit(producer);
service.shutdown();
}
}
原因分析：
1、假设前面有2个producer(此时available=true)
1.1、一个在等待lock
1.2、一个await
2、consumer生成内容后，available=false，produced.signal(); 最后lock.unlock();
3.1、因为lock.unlock所以会触发一个lock获取到锁（虽然signal也会触发等待这个条件的其他线程，但是多线程大家都知道什么时候触发这是不确定的），如果此时正好是[1.1]那么因为available=false，执行完释放锁
3.2、produced.signal()所以会触发一个await的producer；
解决方案：
只要保证[3.1]还是需要await即可解决问题
所以加一个 AtomicInteger producedAwaitCounter = new AtomicInteger(0); 统计当前等待的生产者，如果当前available=false，但已经有生产者生成了内容，那么先等待消费者消费了再说
if (available || producedAwaitCounter.get() > 0) {
producedAwaitCounter.incrementAndGet();
produced.await(); // 放弃lock进入睡眠
producedAwaitCounter.decrementAndGet();
}
当然最简单的是使用：自旋，原理可以自己分析下：
while (available) {
produced.await(); // 放弃lock进入睡眠
}
package com.sishuok.es.test;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//生产/消费者模式
public class Basket {
Lock lock = new ReentrantLock(true);
// 产生Condition对象
Condition produced = lock.newCondition();
Condition consumed = lock.newCondition();
boolean available = false;
AtomicInteger producedAwaitCounter = new AtomicInteger(0);
public void produce() throws InterruptedException {
lock.lock();
try {
if (available || producedAwaitCounter.get() > 0) {
producedAwaitCounter.incrementAndGet();
produced.await(); // 放弃lock进入睡眠
producedAwaitCounter.decrementAndGet();
}
System.out.println("Apple produced.");
available = true;
consumed.signal(); // 发信号唤醒等待这个Condition的线程
} finally {
lock.unlock();
}
}
public void consume() throws InterruptedException {
lock.lock();
try {
if (!available) {
consumed.await(); // 放弃lock进入睡眠
}
/* 吃苹果 */
System.out.println("Apple consumed.");
available = false;
produced.signal(); // 发信号唤醒等待这个Condition的线程
} finally {
lock.unlock();
}
}
}
在回答里还一个类似的，不过还是不太一样。
http://blog.csdn.net/liguogangde/article/details/9103501
你是liguogang？
相关推荐
a: 创建一个线程 ...h: problem1 生产者消费者问题 (1生产者 1消费者 1缓冲区) problem1 more 生产者消费者问题 (1生产者 2消费者 4缓冲区) problem2 读者与写着问题 I: 信号量 semaphore 解决线程同步问题
第一行说明程序中设置几个临界区，其余每行分别描述了一个生产者或者消费者线程的信息。每一行的各字段间用Tab键隔开。不管是消费者还是生产者，都有一个对应的线程号，即每一行开始字段那个整数。第二个字段用字母...
│ 高并发编程第一阶段26讲、多线程下的生产者消费者模型，以及详细介绍notifyAll方法.mp4 │ 高并发编程第一阶段27讲、wait和sleep的本质区别是什么，深入分析（面试常见问题）.mp4 │ 高并发编程第一阶段28讲、...
│ 高并发编程第一阶段26讲、多线程下的生产者消费者模型，以及详细介绍notifyAll方法.mp4 │ 高并发编程第一阶段27讲、wait和sleep的本质区别是什么，深入分析（面试常见问题）.mp4 │ 高并发编程第一阶段28讲、...
说这个话其实只有一半对，因为反应“多角色”的程序代码，最起码每个角色要给他一个线程吧，否则连实际场景都无法模拟，当然也没法说能用单线程来实现：比如最常见的“生产者，消费者模型”。很多人都对其中的一些...
（1）如果设计正确，多线程程序可以通过提高处理器资源的利用率来提升系统吞吐率 （2）建模简单：通过使用线程可以讲复杂并且异步的工作流进一步分解成一组简单并且同步的工作流，每个工作流在一个单独的线程...
13.2.1 一段令人困惑的字符串程序 248 13.2.2 “一次投入，终身回报”的String内存机制 249 13.2.3 String对象特殊机制付出的代价 252 13.3 StringBuffer类 253 13.3.1 弥补String不足的StringBuffer类 ...
生产者、消费者问题；线程的优先级；列出虚拟机中所有的线程；守护线程Daemon；线程池；一个死锁的例子； 定时器Timer：包括在指定时间执行任务，在指定时间之后执行任务以及在某个时间之后每隔时间段重复执行的任务...
05 生产者消费者模型 06 第三次作业讲解 第20章 01 上节课回顾 02 装饰器基本理论 03 高阶函数使用 04 函数闭包 05 函数闭包装饰器基本实现 06 函数闭包加上返回值 07 函数闭包加上参数 08 函数闭包补充：解压序列...
8.4.4生产者-消费者问题实例284 8.5本章小结287 第9章运行时类型识别288 9.1RTTI的作用288 9.2用Class类来加载对象289 9.3使用getClass()方法获取类信息290 9.4使用类标记292 9.5使用关键字instanceof判断...
12.synchronized (生产者和消费） 13.String 和 StringBuffer 14.Serializable 15.MVC （Struts的工作流程） 16.什么是MDA 17.tcp与udp的区别 18.链表与散列表和数组的区别 19.堆和栈的区别 20.ejb的分类及...
3.1.3 多个语句构成代码组（） 3.1.4 代码组由不同的缩进分隔 3.1.5 同一行书写多个语句（;） 3.1.6 模块 3.2 变量赋值 3.2.1 赋值操作符 3.2.2 增量赋值 3.2.3 多重赋值 ...
ANDROID 的推出后可能影响的产业包括移动电信业，软件开发业，手机制造业，在以消费者为核心的状 态 。 对消费者的影响 � 高档手机选择面增加。 � Ａ ndroid 在设计初期就考虑了与现其有业务的融合，改变以往从...
第一章程序和程序设计 .......................................................................................................1 §1.1 什么是程序 ?........................................................