java 队列消费者_Java阻塞队列(BlockingQueue)实现 生产者/消费者 示例

Java阻塞队列(BlockingQueue)实现 生产者/消费者 示例

Java.util.concurrent.BlockingQueue 是一个队列实现类，支持这样的操作：当从队列中获取或者移除元素时，如果队列为空，需要等待，直到队列不为空；同时如果向队列中添加元素时，此时如果队列无可用空间，也需要等待。

BlockingQueue 类不接收Null值，如果你试图向队列中存入Null值将抛出NullPointerException.

BlockingQueue的实现是线程安全的。所有队列方法本身都是原子操作，使用并发控制的内部锁或者其它形式。

BlockingQueue这个接口是Java集合架构的一部分，它主要用于解决生产者/消费者问题。在BlockingQueue中，我们不用担心生产者操作时是否有可用空间或者消费者操作时是否有可用的对像而等待这样的问题，这些都会在它的实现类中进行处理。

Java中提供了几个对BlockingQueue的实现类，如: ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue 等

在处理生产者/消费者问题上 我们将会使用ArrayBlockingQueue来实现，如下是我们需知道的重要方法：

put(E e): 这个方法用于向队列中插入元素，如果队列已满，需要等待可用的这间。

E take(): 这个方法用于从队列头部获取或者移除元素，如果队列为空则需要等待可用的元素。

现在咱们看看用BlockingQueue来解决生产者/消费者问题。

Message

Producer产生的普通Java对象，并添加到队列中。

Message.java

1 packagecom.journaldev.concurrency;2

3 public classMessage {4 privateString msg;5

6 publicMessage(String str){7 this.msg=str;8 }9

10 publicString getMsg() {11 returnmsg;12 }13

14 }

Producer

Producer这个类会产生消息并将其放入队列中。

Producer.java

packagecom.journaldev.concurrency;importjava.util.concurrent.BlockingQueue;public class Producer implementsRunnable {private BlockingQueuequeue;public Producer(BlockingQueueq){this.queue=q;

}

@Overridepublic voidrun() {//生产消息

for(int i=0; i<100; i++){

Message msg= new Message(""+i);try{

Thread.sleep(i);

queue.put(msg);

System.out.println("Produced "+msg.getMsg());

}catch(InterruptedException e) {

e.printStackTrace();

}

}//添加退出消息

Message msg = new Message("exit");try{

queue.put(msg);

}catch(InterruptedException e) {

e.printStackTrace();

}

}

}

Consumer

Consumer类会从队列获取消息进行处理。如果获取的是退出消息则结束。

Consumer.java

packagecom.journaldev.concurrency;importjava.util.concurrent.BlockingQueue;public class Consumer implementsRunnable{private BlockingQueuequeue;public Consumer(BlockingQueueq){this.queue=q;

}

@Overridepublic voidrun() {try{

Message msg;//获取并处理消息直到接收到“exit”消息

while((msg = queue.take()).getMsg() !="exit"){

Thread.sleep(10);

System.out.println("Consumed "+msg.getMsg());

}

}catch(InterruptedException e) {

e.printStackTrace();

}

}

}

ProducerConsumerService

生产者/消费者的服务类将会产生固定大小的BlockingQueue，生产者和消费者同时共享该BlockingQueue，该服务类会起启动生产者和消费者线程。

ProducerConsumerService.java

1 packagecom.journaldev.concurrency;2

3

4 importjava.util.concurrent.ArrayBlockingQueue;5 importjava.util.concurrent.BlockingQueue;6

7

8 public classProducerConsumerService {9

10 public static voidmain(String[] args) {11 //创建大小为10的 BlockingQueue

12 BlockingQueue queue = new ArrayBlockingQueue<>(10);13 Producer producer = newProducer(queue);14 Consumer consumer = newConsumer(queue);15 //开启 producer线程向队列中生产消息

16 newThread(producer).start();17 //开启 consumer线程 中队列中消费消息

18 newThread(consumer).start();19 System.out.println("Producer and Consumer has been started");20 }21

22 }

上面程序的运行结果:

1 Producer and Consumer has been started2 Produced 0

3 Produced 1

4 Produced 2

5 Produced 3

6 Produced 4

7 Consumed 0

8 Produced 5

9 Consumed 1

10 Produced 6

11 Produced 7

12 Consumed 2

13 Produced 8

14 ...

Thread sleep 使得生产者/消费者 生产、消费这此消息有一定的延迟。

[ 转载请保留原文出处、译者和译文链接。]