上一篇博客主要学习了线程安全问题,以及简单的线程等待唤醒机制。这篇博客,基于上一篇的基础之上学习”生产者和消费者”,如果我有这样一个需求,即没生产一个商品就将其消费掉。
资源类
先看下Resource.java
package com.test.product.consumer;
public class Resource {
private String name;
private int count = 1; //用来标志当前资源的id
private boolean flag = false; //标志当前线程是否可以被唤醒
public synchronized void setName(String name) {
if (flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.name = name + "=="+count++;
System.out.println(Thread.currentThread().getName()+"===生产了"+this.name);
flag = true;
this.notify();
}
public synchronized void get() {
if (!flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"===========消费了"+this.name);
flag = false;
this.notify();
}
}
如果你看过了java多线程学习,这里无需多说了。生产和消费都是在同一个资源类里,并且这里每生产一个和消费一个,我们都将其打印出来。这里在操作共享数据的方法前加上synchronized关键字,用来保证线程安全问题,使用flag保证当前线程是否需要等待以及是否可以唤醒其他线程。
生产者消费者
生产者
package com.test.product.consumer;
/**
* 生成者 不断的生成商品
* @author admin
*
*/
public class Product implements Runnable{
private Resource resource;
public Product(Resource resource) {
this.resource = resource;
}
@Override
public void run() {
while (true) {
resource.setName("produce");
}
}
}
消费者
package com.test.product.consumer;
/**
* 消费者 不断的消费商品
* @author admin
*
*/
public class Consumer implements Runnable{
private Resource resource;
public Consumer(Resource resource) {
this.resource = resource;
}
@Override
public void run() {
while (true) {
resource.get();
}
}
}
测试生产者消费者
Resource resource = new Resource();
Product product = new Product(resource);
Consumer consumer = new Consumer(resource);
Thread t1 = new Thread(product);
Thread t2 = new Thread(consumer);
t1.start();
t2.start();
这里生产者没生产一个商品,就唤醒消费者线程来消费,自己则处于等待状态,当消费者消费完成该商品,则唤醒生产者继续生产,此时消费者则处于等待状态。运行效果:
可以看到此时生产者每生产一个商品,就会被消费者消费掉。
遇到的问题
上面虽然完成了一个简单的生产者消费者的案例,但是还存在一下问题,就是现实生活中可能有很多的生产者用来生产,很多的消费者来完成消费,那么此时如果我在增加一个生产者和消费者:
Resource resource = new Resource();
Product product = new Product(resource);
Consumer consumer = new Consumer(resource);
Thread t1 = new Thread(product);
Thread t2 = new Thread(product);
Thread t3 = new Thread(product);
Thread t4 = new Thread(consumer);
Thread t5 = new Thread(consumer);
Thread t6 = new Thread(consumer);
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
此时运行效果如下:
可以看到会出现生产者只生产了一个produce,然而消费者却消费了两次,这显然是不对的。这是因为由于使用的是if判断是否需要等待,导致有的生产者或者消费者被唤醒以后没有运行该wait语句,所以我们需要将if改为while即可。
此时再次运行:
此时虽然可以实现”没生产一个消费一个的要求”,可是会发现,所有的线程都将处于等待状态,此时只需要将notify方法,改为notifyAll即可。
小结
- 对于多个生产者和消费者,使用while来作为判断标记是因为需要让被唤醒的线程在做一次标记的判断
- 使用notifyAll方法唤醒线程,是因为需要唤醒对方的线程,防止程序中所有的线程都处于等待状态。
Lock,Condition替换synchronized
上面的代码有一个问题,就是我们为了避免所有的线程都处于等待的状态,使用了notifyAll方法来唤醒所有的线程,如果我需要只是唤醒对方的线程,比如:生产者只能唤醒消费者的线程,消费者只能唤醒生产者的线程。
在jdk1.5当中为我们提供了多线程的升级解决方案:
1. 将同步synchronized替换成了Lock操作
2. 将Object中的wait,notify,notifyAll方法替换成了Condition对象
3. 可以只唤醒对方的线程
使用Lock方式修改后的Resource.java:
package com.five.product.consumer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Resource {
private String name;
private int count = 1; //用来标志当前资源的id
private boolean flag = false; //标志当前线程是否可以被唤醒
private Lock lock = new ReentrantLock();
private Condition condition_pro = lock.newCondition(); //生产者
private Condition condition_con = lock.newCondition(); //消费者
public void setName(String name) throws InterruptedException {
try {
lock.lock();
while (flag) {
condition_pro.await();
}
this.name = name + "=="+count++;
System.out.println(Thread.currentThread().getName()+"===生产了"+this.name);
flag = true;
condition_con.signal();
} finally {
lock.unlock();
}
}
public void get() throws InterruptedException {
try {
lock.lock();
while (!flag) {
condition_con.await();
}
System.out.println(Thread.currentThread().getName()+"=======消费了"+this.name);
flag = false;
condition_pro.signal();
} finally {
lock.unlock();
}
}
}
ok,关于生产者和消费者的学习就到这里了。