[英]Blocked using wait() and notify() in Java
我正在使用Java中的wait()
和notify()
编写生产者和消费者代码。 创建Thread-0并在produce()
上调用,并创建Thread-1并在consume()
上调用。
public class Processor {
private volatile List<Integer> list = new ArrayList<>();
private final int MAX_CAPACITY = 5;
Object lock = new Object();
public void produce() throws InterruptedException {
while (true) {
while (list.size() == MAX_CAPACITY) {
System.out.println("List is full! Producer is Waiting....");
synchronized (lock) {
lock.wait();
}
}
synchronized (lock) {
int random = new Random().nextInt(100);
list.add(random);
System.out.println("Added to list:" + random);
lock.notify();
}
}
}
public void consume() throws InterruptedException {
while (true) {
while (list.size() == 0) {
System.out.println("List is empty!! Consumer is Waiting...");
synchronized (lock) {
lock.wait();
}
}
synchronized (lock) {
int i = list.remove(0);
System.out.println("Removed from list:" + i);
lock.notify();
}
}
}
}
问题是在执行期间,程序在produce()
之后停止:
List is empty!! Consumer is Waiting...
Added to list:22
Added to list:45
Added to list:72
Added to list:91
Added to list:51
List is full! Producer is Waiting....
我无法理解这里的问题是什么。 我以某种方式弄清楚将while
循环中的代码包装在produce()
和consume()
中的synchronized
块中解决了这个问题。
produce()
synchronized (lock) {
while (list.size() == MAX_CAPACITY) {
System.out.println("List is full! Producer is Waiting....");
lock.wait();
}
consume
synchronized (lock) {
while (list.size() == 0) {
System.out.println("List is empty!! Consumer is Waiting...");
lock.wait();
}
}
这是什么问题? 这是线程饥饿还是死锁的情况?
编辑:调用类:
public class App {
public static void main(String[] args) {
final Processor processor = new Processor();
Runnable r1 = new Runnable() {
@Override
public void run() {
try {
processor.produce();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Runnable r2 = new Runnable() {
@Override
public void run() {
try {
processor.consume();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
当你执行list.size()
它不是线程安全的,并且没有保证你将看到另一个线程中的值发生了变化。 如果JIT检测到您没有在该线程中更改它,则它甚至可以内联该值。
通过将synchronized
块放在循环外部,可确保值的变化可见(因为它也在while(true)
循环内while(true)
。
使用synchronized
外部循环创建读取障碍 。 因此,生产者/消费者将在您检查list.size()
环路中看到最新的list
。 这就是为什么你移动后,它的工作原理while
内循环synchronized
块。
在您的情况下,我还建议您在生产者/消费者中使用单个同步块。
例如,在您的实现中,如果list.size() == 0
对于使用者变为false
,它将释放对lock
对象的锁定,然后在下一个语句中尝试再次获取锁定以消耗数据,这是不必要且低效的。 应该是这样的:
public void consume() throws InterruptedException {
while (true) {
synchronized (lock) {
while (list.size() == 0) {
System.out.println("List is empty!! Consumer is Waiting...");
lock.wait();
}
int i = list.remove(0);
System.out.println("Removed from list:" + i);
lock.notify();
}
}
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.