生产这消费者,自己还是dubbo中听说的。但这其实是一个经典的线程问题。
者和消费者在同一时间段内共用同一存储空间,生产者向空间里生产数据,而消费者消费数据。
阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。
我这里以wait和notifyAll方法实现。
写的比较简单直接代码了:
package com.storage;
import java.util.LinkedList;
public class Storage {
//缓冲区
private final int MAX = 100;//仓库最大存储
private LinkedList<Object> list = new LinkedList<Object>();
/**
*
* @param 生产方法
*/
//生产方法,生产产品
public void produce(String producer){
synchronized (list) {
//欢唱仓库是否已满
while (list.size() == MAX) {
System.out.println("仓库已满," + producer + ": 暂时不能执行生产任务!");
try {
list.wait();
} catch (InterruptedException e) {//阻塞方法收到中断请求
e.printStackTrace();
}
}
//生产产品
list.add(new Object());
System.out.println(producer+":生产了一个产品\t【现仓储量为】:" + list.size());
list.notifyAll();//唤醒线程
}
}
/**
*
* @param 消费方法
*/
//消费方法
public void consume(String consumer){
synchronized (list){
//判断仓库是否为空
while (list.size() == 0){
System.out.println("仓库已空,"+consumer+": 暂时不能执行消费任务!");
try {
list.wait();
} catch (InterruptedException e) {//阻塞方法收到中断请求
e.printStackTrace();
}
}
//消费产品
list.remove();
System.out.println(consumer+":消费了一个产品\t【现仓储量为】:" + list.size());
list.notifyAll();
}
}
public int getMAX() {
return MAX;
}
public LinkedList<Object> getList() {
return list;
}
public void setList(LinkedList<Object> list) {
this.list = list;
}
}
测试
package com.storage;
public class test {
public static void main(String[] args) {
Storage storage = new Storage();
//生产方法
for (int i = 0; i < 5 ; i++) {
int j = i;
new Thread(new Runnable() {
@Override
public void run() {
storage.produce(String.format("生产者%d:",j));
}
}).start();
}
//消费方法
for (int i = 1; i < 4 ;i++){
int j = i;
new Thread(new Runnable() {
@Override
public void run() {
storage.consume(String.format("消费者%d:",j));
}
}).start();
}
}
}
运行结果
生产者2::生产了一个产品 【现仓储量为】:1
生产者3::生产了一个产品 【现仓储量为】:2
生产者0::生产了一个产品 【现仓储量为】:3
消费者2::消费了一个产品 【现仓储量为】:2
消费者3::消费了一个产品 【现仓储量为】:1
消费者1::消费了一个产品 【现仓储量为】:0
生产者1::生产了一个产品 【现仓储量为】:1
生产者4::生产了一个产品 【现仓储量为】:2
参考:
https://blog.csdn.net/shadowcw/article/details/82352829