1.与保护性暂停GuardedObject不同,不需要产生结果与消费结果的线程一一对应。
2.消费队列可以用来平衡生产和消费的线程资源。
3.生产者负责产生结果数据,不关心数据该如何处理,而消费者专心处理结果数据。
4.消息队列是有容量限制的,满时不会再加入数据,空时不会再消耗数据。
5.jdk中各种阻塞队列,就是采用这种模式。
public class QueueDemo {
public static void main(String[] args) {
MessageQueue messageQueue = new MessageQueue(2);
for (int i = 0; i < 3; i++) {
int index = i;
new Thread(() -> {
Message msg = new Message(index, "msg"+index);
messageQueue.put(msg);
}, "生产者").start();
}
new Thread(() -> {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message message = messageQueue.take();
System.out.println("取出的message="+message);
}
}, "消费者").start();
}
}
class MessageQueue {
//双向队列
private LinkedList<Message> linkedList = new LinkedList<>();
//容量
private int capcity;
public MessageQueue(int capcity) {
this.capcity = capcity;
}
/**
* 取消息
* @return
*/
public Message take() {
synchronized (linkedList) {
while (linkedList.isEmpty()) {
try {
System.out.println("队列为空,消费者等待");
linkedList.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//返回头元素
Message message = linkedList.removeFirst();
System.out.println("取出一条消息:"+message);
linkedList.notifyAll();
return message;
}
}
/**
* 放入消息
*/
public void put(Message message) {
synchronized (linkedList) {
while(linkedList.size() == capcity) {
try {
System.out.println("队列已满,生产者等待");
linkedList.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//添加到链表尾部
linkedList.addLast(message);
System.out.println("放入一条消息:"+message);
//唤醒取消息线程
linkedList.notifyAll();
}
}
}
final class Message {
private int id;
private Object value;
public Message(int id, Object value) {
this.id = id;
this.value = value;
}
public int getId() {
return id;
}
public Object getValue() {
return value;
}
@Override
public String toString() {
return "Message{" +
"id=" + id +
", value=" + value +
'}';
}
}
标签:异步,linkedList,23,生产者,Message,value,int,message,public
From: https://blog.csdn.net/qq_36352889/article/details/137028817