编写一个队列,生产者生产消息(消息内容是1,2,3,…,n),消费者消费消息,并将消息打印到控制台。
要求:
- 生产者以每秒10个的速率生产消息,队列满了后阻塞等待;
- 队列长度为100;
- 消费者以每秒1个的速率消费消息;
生产者和消费者在不同的线程; - 起20个消费者线程;
- 消费者取不到消息的时候阻塞等待;
- 不能重复消费;
import java.util.concurrent.*;
class Message {
private final int value;
public Message(int value) {
this.value = value;
}
public int getValue() {
return value;
}
}
class Producer implements Runnable {
private final BlockingQueue<Message> queue;
public Producer(BlockingQueue<Message> queue) {
this.queue = queue;
}
@Override
public void run() {
try {
for (int i = 1; i <= 1000; i++) {
Message message = new Message(i);
queue.put(message);
System.out.println("Produced: " + message.getValue());
Thread.sleep(100); // 生产者以每秒10个的速率生产消息
synchronized (this) {
while (queue.remainingCapacity() == 0) {
wait();
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Consumer implements Runnable {
private final BlockingQueue<Message> queue;
private final Semaphore semaphore;
public Consumer(BlockingQueue<Message> queue, Semaphore semaphore) {
this.queue = queue;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
while (true) {
Message message = queue.take(); // 取不到消息时阻塞等待
System.out.println("Consumed: " + message.getValue());
semaphore.acquire(); // 不能重复消费,使用信号量控制消费者数量
Thread.sleep(1000); // 消费者以每秒1个的速率消费消息
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release(); // 释放信号量,允许其他消费者继续消费
}
}
}
public class Main {
public static void main(String[] args) {
int numConsumers = 20; // 起20个消费者线程
Semaphore semaphore = new Semaphore(numConsumers); // 控制消费者数量
BlockingQueue<Message> queue = new LinkedBlockingQueue<>(100); // 队列长度为100
Producer producer = new Producer(queue); // 生产者线程
for (int i = 0; i < numConsumers; i++) { // 创建20个消费者线程并启动它们
new Thread(new Consumer(queue, semaphore)).start(); // 消费者线程,取不到消息时阻塞等待,不能重复消费,每秒消费1个消息,最多同时有20个消费者线程在运行。
} // 启动生产者线程,每秒生产10个消息,队列满后阻塞等待。生产者和消费者在不同的线程中运行。
}
}