其实这种场景在现实中随处可见,比如一个人负责往盒子中放苹果,一个人负责从盒子中拿出苹果吃,这样就形成了一个生产一个消费的场景。
生产者和消费者模式通过分离执行方式进行解耦,简化了开发的难度。
我们来实现下上面这个例子:
生产者:往一个公共盒子中放入苹果
消费者:从这个盒子中取出苹果
盒子:盒子数量不能超过5个
盒子:
public class PublicBox {
private int apple =0;
public synchronized void increace(){
while(apple == 5){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
apple++;
System.out.println("生成苹果成功!");
notify();
}
public synchronized void decreace(){
while (apple == 0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
apple--;
System.out.println("消费苹果成功!");
notify();
}
public static void main (String[] args){
PublicBox box = new PublicBox();
Consumer con = new Consumer(box);
Producer pro = new Producer(box);
Thread t1 = new Thread(con);
Thread t2 = new Thread(pro);
t1.start();
t2.start();
}
}
生产者:
public class Producer implements Runnable {
private PublicBox box;
public Producer(PublicBox box) {
this.box = box;
}
@Override
public void run() {
for(int i= 0 ;i<10 ; i++){
try {
System.out.println("pro i:" + i);
Thread.sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
box.increace();
}
}
}
消费者:
public class Consumer implements Runnable {
private PublicBox box;
public Consumer(PublicBox box) {
this.box = box;
}
@Override
public void run() {
for(int i= 0 ;i<10;i++ ){
try {
System.out.println("Con i:" + i);
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
box.decreace();
}
}
}
运行结果:
pro i:0
Con i:0
生成苹果成功!
pro i:1
生成苹果成功!
pro i:2
生成苹果成功!
pro i:3
生成苹果成功!
pro i:4
生成苹果成功!
pro i:5
消费苹果成功!
Con i:1
生成苹果成功!
pro i:6
消费苹果成功!
Con i:2
生成苹果成功!
pro i:7
消费苹果成功!
Con i:3
生成苹果成功!
pro i:8
消费苹果成功!
Con i:4
生成苹果成功!
pro i:9
消费苹果成功!
Con i:5
生成苹果成功!
消费苹果成功!
Con i:6
消费苹果成功!
Con i:7
消费苹果成功!
Con i:8
消费苹果成功!
Con i:9
消费苹果成功!