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

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

本文由 TonySpark 翻译自 Javarevisited。转载请参见文章末尾的要求。

     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

package com.journaldev.concurrency;
 
public class Message {
    private String msg;
     
    public Message(String str){
        this.msg=str;
    }
 
    public String getMsg() {
        return msg;
    }
 
}

Producer

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

Producer.java

package com.journaldev.concurrency;
 
import java.util.concurrent.BlockingQueue;
 
public class Producer implements Runnable {
 
    private BlockingQueue<Message> queue;
     
    public Producer(BlockingQueue<Message> q){
        this.queue=q;
    }
    @Override
    public void run() {
        //生产消息
        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

package com.journaldev.concurrency;
 
import java.util.concurrent.BlockingQueue;
 
public class Consumer implements Runnable{
 
private BlockingQueue<Message> queue;
     
    public Consumer(BlockingQueue<Message> q){
        this.queue=q;
    }
 
    @Override
    public void run() {
        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

package com.journaldev.concurrency;
 
 
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
 
 
public class ProducerConsumerService {
 
    public static void main(String[] args) {
        //创建大小为10的 BlockingQueue 
        BlockingQueue<Message> queue = new ArrayBlockingQueue<>(10);
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);
        //开启 producer线程向队列中生产消息
        new Thread(producer).start();
        //开启 consumer线程 中队列中消费消息
        new Thread(consumer).start();
        System.out.println("Producer and Consumer has been started");
    }
 
}

上面程序的运行结果:

Producer and Consumer has been started
Produced 0
Produced 1
Produced 2
Produced 3
Produced 4
Consumed 0
Produced 5
Consumed 1
Produced 6
Produced 7
Consumed 2
Produced 8
...

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

 

原文链接： Javarevisited 翻译： TonySpark
译文链接： http://www.cnblogs.com/tonyspark/p/3722013.html

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