package producerConsumer;
public class Test {
public static void main(String[] args) {
new Test().run();
}
public void run(){
WareHouse wh = new WareHouse(30);
Consumer c1 = new Consumer(50, wh);
Consumer c2 = new Consumer(20, wh);
Consumer c3 = new Consumer(30, wh);
Producer p1 = new Producer(10, wh);
Producer p2 = new Producer(10, wh);
Producer p3 = new Producer(10, wh);
Producer p4 = new Producer(10, wh);
Producer p5 = new Producer(10, wh);
Producer p6 = new Producer(10, wh);
Producer p7 = new Producer(80, wh);
c1.start();
c2.start();
c3.start();
p1.start();
p2.start();
p3.start();
p4.start();
p5.start();
p6.start();
p7.start();
}
class WareHouse{
public static final int MAX_SIZE = 100;//最大库存量
public int curNum;//当前库存量
public WareHouse(){
}
public WareHouse(int curNum){
this.curNum = curNum;
}
/**
* 生产指定数量的产品
* @param needNum
*/
public synchronized void produce(int needNum){
//测试是否要生产
while(needNum + curNum > MAX_SIZE){
System.out.println("要生产的产品数量"+needNum+
"超过最大库存量"+(curNum+needNum-MAX_SIZE)+
" 暂时不能执行任务!");
System.out.println("生产者在等待消费者进行消费。。。");
try {
//WareHouse对象通知调用它的CurrentThread即
//Producer对象进行等待
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
curNum += needNum;
System.out.println("已经生产了"+needNum+"个产品,现仓储量为"+curNum);
//唤醒在此监视器上等待的所有线程
notifyAll();
}
/**
* 消费指定数量的产品
* @param needNum
*/
public synchronized void consume(int needNum){
//测试是否可消费
while(curNum < needNum){
//WareHouse通知Consumer进行等待直到curNum>needNum
System.out.println("消费者在等待生产者进行生产。。。");
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//满足消费条件,进行消费
curNum -= needNum;
System.out.println("已经消费了"+needNum+"个产品,现仓储量为"+curNum);
notifyAll();
}
}
class Producer extends Thread{
private int needNum;
private WareHouse wareHouse;
public Producer(int needNum, WareHouse wareHouse) {
this.needNum = needNum;
this.wareHouse = wareHouse;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"生产数量"+needNum);
wareHouse.produce(needNum);
}
}
class Consumer extends Thread{
private int needNum;
private WareHouse wareHouse;
public Consumer(int needNum, WareHouse wareHouse) {
this.needNum = needNum;
this.wareHouse = wareHouse;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"消费数量"+needNum);
wareHouse.consume(needNum);
}
}
}
本例仅仅是生产者消费者模型中最简单的一种表示,本例中,如果消费者消费的仓储量达不到满足,而又没有生产者,则程序会一直处于等待状态,这当然是不对的。实际上可以将此例进行修改,修改为,根据消费驱动生产,同时生产兼顾仓库,如果仓不满
就生产,并对每次最大消费量做个限制,这样就不存在此问题了,当然这样的例子更复杂,更难以说明这样一个简单模型。
运行结果1:
Thread-0消费数量50
Thread-2消费数量30
Thread-1消费数量20
消费者在等待生产者进行生产。。。
已经消费了20个产品,现仓储量为10
消费者在等待生产者进行生产。。。
消费者在等待生产者进行生产。。。
Thread-4生产数量10
Thread-5生产数量10
Thread-7生产数量10
Thread-3生产数量10
Thread-8生产数量10
Thread-9生产数量80
Thread-6生产数量10
已经生产了10个产品,现仓储量为20
消费者在等待生产者进行生产。。。
消费者在等待生产者进行生产。。。
已经生产了10个产品,现仓储量为30
要生产的产品数量80超过最大库存量10 暂时不能执行任务!
生产者在等待消费者进行消费。。。
已经生产了10个产品,现仓储量为40
已经生产了10个产品,现仓储量为50
已经生产了10个产品,现仓储量为60
已经生产了10个产品,现仓储量为70
要生产的产品数量80超过最大库存量50 暂时不能执行任务!
生产者在等待消费者进行消费。。。
已经消费了30个产品,现仓储量为40
消费者在等待生产者进行生产。。。
要生产的产品数量80超过最大库存量20 暂时不能执行任务!
生产者在等待消费者进行消费。。。
运行结果2
Thread-1消费数量20
Thread-0消费数量50
Thread-5生产数量10
Thread-3生产数量10
Thread-2消费数量30
已经消费了20个产品,现仓储量为10
Thread-4生产数量10
消费者在等待生产者进行生产。。。
Thread-6生产数量10
已经生产了10个产品,现仓储量为20
已经生产了10个产品,现仓储量为30
Thread-7生产数量10
消费者在等待生产者进行生产。。。
已经生产了10个产品,现仓储量为40
已经消费了30个产品,现仓储量为10
已经生产了10个产品,现仓储量为20
已经生产了10个产品,现仓储量为30
消费者在等待生产者进行生产。。。
Thread-8生产数量10
Thread-9生产数量80
要生产的产品数量80超过最大库存量10 暂时不能执行任务!
生产者在等待消费者进行消费。。。
已经生产了10个产品,现仓储量为40
要生产的产品数量80超过最大库存量20 暂时不能执行任务!
生产者在等待消费者进行消费。。。
消费者在等待生产者进行生产。。。
如何在 Java 中正确使用 wait, notify 和 notifyAll
在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。。举个例子,如果你的Java程序中有两个线程——即生产者和消费者,那么生产者可以通知消费者,让消费者开始消耗数据,因为队列缓 冲区中有内容待消费(不为空)。相应的,消费者可以通知生产者可以开始生成更多的数据,因为当它消耗掉某些数据后缓冲区不再为满。
-
作者:
来源:ImportNew|
2015-08-05 09:33
wait, notify 和 notifyAll,这些在多线程中被经常用到的保留关键字,在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。
在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。。举个例子,如果你的Java程序中有两个线程——即生产者和消费者,那么生产者可以通知消费者,让消费者开始消耗数据,因为队列缓 冲区中有内容待消费(不为空)。相应的,消费者可以通知生产者可以开始生成更多的数据,因为当它消耗掉某些数据后缓冲区不再为满。
我们可以利用wait()来让一个线程在某些条件下暂停运行。例如,在生产者消费者模型中,生产者线程在缓冲区为满的时候,消费者在缓冲区为空的时 候,都应该暂停运行。如果某些线程在等待某些条件触发,那当那些条件为真时,你可以用 notify 和 notifyAll 来通知那些等待中的线程重新开始运行。不同之处在于,notify 仅仅通知一个线程,并且我们不知道哪个线程会收到通知,然而 notifyAll 会通知所有等待中的线程。换言之,如果只有一个线程在等待一个信号灯,notify和notifyAll都会通知到这个线程。但如果多个线程在等待这个信 号灯,那么notify只会通知到其中一个,而其它线程并不会收到任何通知,而notifyAll会唤醒所有等待中的线程。
在这篇文章中你将会学到如何使用 wait、notify 和 notifyAll 来实现线程间的通信,从而解决生产者消费者问题。如果你想要更深入地学习Java中的多线程同步问题,我强烈推荐阅读Brian Goetz所著的《Java Concurrency in Practice | Java 并发实践》,不读这本书你的 Java 多线程征程就不完整哦!这是我最向Java开发者推荐的书之一。
如何使用Wait
尽管关于wait和notify的概念很基础,它们也都是Object类的函数,但用它们来写代码却并不简单。如果你在面试中让应聘者来手写代码, 用wait和notify解决生产者消费者问题,我几乎可以肯定他们中的大多数都会无所适从或者犯下一些错误,例如在错误的地方使用 synchronized 关键词,没有对正确的对象使用wait,或者没有遵循规范的代码方法。说实话,这个问题对于不常使用它们的程序员来说确实令人感觉比较头疼。
第一个问题就是,我们怎么在代码里使用wait()呢?因为wait()并不是Thread类下的函数,我们并不能使用 Thread.call()。事实上很多Java程序员都喜欢这么写,因为它们习惯了使用Thread.sleep(),所以他们会试图使用wait() 来达成相同的目的,但很快他们就会发现这并不能顺利解决问题。正确的方法是对在多线程间共享的那个Object来使用wait。在生产者消费者问题中,这 个共享的Object就是那个缓冲区队列。
第二个问题是,既然我们应该在synchronized的函数或是对象里调用wait,那哪个对象应该被synchronized呢?答案是,那个 你希望上锁的对象就应该被synchronized,即那个在多个线程间被共享的对象。在生产者消费者问题中,应该被synchronized的就是那个 缓冲区队列。(我觉得这里是英文原文有问题……本来那个句末就不应该是问号不然不太通……)
永远在循环(loop)里调用 wait 和 notify,不是在 If 语句
现在你知道wait应该永远在被synchronized的背景下和那个被多线程共享的对象上调用,下一个一定要记住的问题就是,你应该永远在 while循环,而不是if语句中调用wait。因为线程是在某些条件下等待的——在我们的例子里,即“如果缓冲区队列是满的话,那么生产者线程应该等 待”,你可能直觉就会写一个if语句。但if语句存在一些微妙的小问题,导致即使条件没被满足,你的线程你也有可能被错误地唤醒。所以如果你不在线程被唤 醒后再次使用while循环检查唤醒条件是否被满足,你的程序就有可能会出错——例如在缓冲区为满的时候生产者继续生成数据,或者缓冲区为空的时候消费者 开始小号数据。所以记住,永远在while循环而不是if语句中使用wait!我会推荐阅读《Effective Java》,这是关于如何正确使用wait和notify的最好的参考资料。
基于以上认知,下面这个是使用wait和notify函数的规范代码模板:
- // The standard idiom for calling the wait method in Java
- synchronized (sharedObject) {
- while (condition) {
- sharedObject.wait();
- // (Releases lock, and reacquires on wakeup)
- }
- // do action based upon condition e.g. take or put into queue
- }
就像我之前说的一样,在while循环里使用wait的目的,是在线程被唤醒的前后都持续检查条件是否被满足。如果条件并未改变,wait被调用之前notify的唤醒通知就来了,那么这个线程并不能保证被唤醒,有可能会导致死锁问题。
Java wait(), notify(), notifyAll() 范例
下面我们提供一个使用wait和notify的范例程序。在这个程序里,我们使用了上文所述的一些代码规范。我们有两个线程,分别名为 PRODUCER(生产者)和CONSUMER(消费者),他们分别继承了了Producer和Consumer类,而Producer和 Consumer都继承了Thread类。Producer和Consumer想要实现的代码逻辑都在run()函数内。Main线程开始了生产者和消费 者线程,并声明了一个LinkedList作为缓冲区队列(在Java中,LinkedList实现了队列的接口)。生产者在无限循环中持续往 LinkedList里插入随机整数直到LinkedList满。我们在while(queue.size == maxSize)循环语句中检查这个条件。请注意到我们在做这个检查条件之前已经在队列对象上使用了synchronized关键词,因而其它线程不能在 我们检查条件时改变这个队列。如果队列满了,那么PRODUCER线程会在CONSUMER线程消耗掉队列里的任意一个整数,并用notify来通知 PRODUCER线程之前持续等待。在我们的例子中,wait和notify都是使用在同一个共享对象上的。
- import java.util.LinkedList;
- import java.util.Queue;
- import java.util.Random;
- /**
- * Simple Java program to demonstrate How to use wait, notify and notifyAll()
- * method in Java by solving producer consumer problem.
- *
- * @author Javin Paul
- */
- public class ProducerConsumerInJava {
- public static void main(String args[]) {
- System.out.println("How to use wait and notify method in Java");
- System.out.println("Solving Producer Consumper Problem");
- Queue<Integer> buffer = new LinkedList<>();
- int maxSize = 10;
- Thread producer = new Producer(buffer, maxSize, "PRODUCER");
- Thread consumer = new Consumer(buffer, maxSize, "CONSUMER");
- producer.start(); consumer.start(); }
- }
- /**
- * Producer Thread will keep producing values for Consumer
- * to consumer. It will use wait() method when Queue is full
- * and use notify() method to send notification to Consumer
- * Thread.
- *
- * @author WINDOWS 8
- *
- */
- class Producer extends Thread
- { private Queue<Integer> queue;
- private int maxSize;
- public Producer(Queue<Integer> queue, int maxSize, String name){
- super(name); this.queue = queue; this.maxSize = maxSize;
- }
- @Override public void run()
- {
- while (true)
- {
- synchronized (queue) {
- while (queue.size() == maxSize) {
- try {
- System.out .println("Queue is full, " + "Producer thread waiting for " + "consumer to take something from queue");
- queue.wait();
- } catch (Exception ex) {
- ex.printStackTrace(); }
- }
- Random random = new Random();
- int i = random.nextInt();
- System.out.println("Producing value : " + i); queue.add(i); queue.notifyAll();
- }
- }
- }
- }
- /**
- * Consumer Thread will consumer values form shared queue.
- * It will also use wait() method to wait if queue is
- * empty. It will also use notify method to send
- * notification to producer thread after consuming values
- * from queue.
- *
- * @author WINDOWS 8
- *
- */
- class Consumer extends Thread {
- private Queue<Integer> queue;
- private int maxSize;
- public Consumer(Queue<Integer> queue, int maxSize, String name){
- super(name);
- this.queue = queue;
- this.maxSize = maxSize;
- }
- @Override public void run() {
- while (true) {
- synchronized (queue) {
- while (queue.isEmpty()) {
- System.out.println("Queue is empty," + "Consumer thread is waiting" + " for producer thread to put something in queue");
- try {
- queue.wait();
- } catch (Exception ex) {
- ex.printStackTrace();
- }
- }
- System.out.println("Consuming value : " + queue.remove()); queue.notifyAll();
- }
- }
- }
- }
为了更好地理解这个程序,我建议你在debug模式里跑这个程序。一旦你在debug模式下启动程序,它会停止在PRODUCER或者 CONSUMER线程上,取决于哪个线程占据了CPU。因为两个线程都有wait()的条件,它们一定会停止,然后你就可以跑这个程序然后看发生什么了 (很有可能它就会输出我们以上展示的内容)。你也可以使用Eclipse里的Step into和Step over按钮来更好地理解多线程间发生的事情。
本文重点:
1. 你可以使用wait和notify函数来实现线程间通信。你可以用它们来实现多线程(>3)之间的通信。
2. 永远在synchronized的函数或对象里使用wait、notify和notifyAll,不然Java虚拟机会生成 IllegalMonitorStateException。
3. 永远在while循环里而不是if语句下使用wait。这样,循环会在线程睡眠前后都检查wait的条件,并在条件实际上并未改变的情况下处理唤醒通知。
4. 永远在多线程间共享的对象(在生产者消费者模型里即缓冲区队列)上使用wait。
5. 基于前文提及的理由,更倾向用 notifyAll(),而不是 notify()。
这是关于Java里如何使用wait, notify和notifyAll的所有重点啦。你应该只在你知道自己要做什么的情况下使用这些函数,不然Java里还有很多其它的用来解决同步问题的方 案。例如,如果你想使用生产者消费者模型的话,你也可以使用BlockingQueue,它会帮你处理所有的线程安全问题和流程控制。如果你想要某一个线 程等待另一个线程做出反馈再继续运行,你也可以使用CycliBarrier或者CountDownLatch。如果你只是想保护某一个资源的话,你也可 以使用Semaphore。