Pratice Of Concurrency(一: BlockingQueue )

Java java.util.currency包中的BlockingQueue接口意味着线程能够在一个队列中添加和提取对象.在接下来的段落中,咱们将学习如何使用BlockingQueue接口.

BlockingQueue的使用

BlockingQueue典型应用是用于一个线程生产对象,另外一个线程消费对象.

下面是一个原理描述图:

一个阻塞队列伴随着一个线程往队列中添加对象,另外一个线程从队列中提取对象.

生产线程负责生产新对象并发它添加进队列中,直到达到队列所能容纳的边界值为止.即达到容量限制.若是队列达到容量限制,则生产线程在插入新对象时将会发生阻塞.直到有一个消费线程从队列中取走一个对象为止.

消费线程负责从阻塞队列中取出对象并处理它们.若是消费线程尝试从空队列中取出空队列,那么消费线程将会阻塞直到生产线程往队列中放入一个对象为止.

BlockingQueue方法

一个阻塞队列包含四种大相径庭的方法集,用于完成在队列中插入,移除和检查元素.每种集合的不一样之处在于操做请求不能被当即执行时的不一样行为.下面是这些方法的列表:

	Throws Exception	Special Value	Blocks	Times Out
Insert	add(o)	offer(o)	put(o)	offer(o, timeout, time unit)
Remove	remove(o)	poll()	take()	poll(timeout, timeunit)
Examine	element()	peek()

四种不一样的行为结合以下:

1. Throws Exception: 当尝试操做不能被当即执行时, 将抛出一个异常
2. Special Value: 当尝试操做不能被当即执行时, 指定一个返回值(一般为 true / false)
3. Blocks: 当尝试操做不能被当即执行时, 阻塞方法调用直到可以执行成功为止
4. Time Out: 当尝试操做不能被当即执行时, 阻塞方法调用直到可以执行成功为止, 但等待不能超过指定的超时时长.若超出时长, 不管成功或失败返回一个指定的值.(典型的例子是 true / false)

不能插入null到BlockingQueue中.若是你这么作了,BlockingQueue将抛出一个NullPointerException.

固然咱们也可以访问BlockingQueue的全部元素, 不仅是队头和队尾. 例如, 你须要出队一个对象用于执行,但你的应用决定取消它.那么你仍然可使用相似remove(o)方法来移除队列中指定的对象.然而这不是很高效,因此你不该该使用这类方法, 除非你真的须要这么作.

BlockingQueue的多种实现

BlockingQueue只是一个接口, 因此你须要使用它众多实现的其中一种来使用它.java.util.concurrency包中有以下几种BlockingQueue的接口实现(在Java6中):

• ArrayBlockingQueue
• DelayQueue
• LinkedBlockingQueue
• PriorityBlockingQueue
• SynchronousQueue

Java BlockingQueue实例

下面是一个Java BlockingQueue的实例. 实例中使用BlockingQueue接口的实现类,ArrayBlockingQueue.

首先,BlockingQueueExample类中分别启动一个生产和消费线程.生产线程负责插入字符串到共享BlockingQueue中,而消费线程则负责取走它们.

public class ArrayBlockingQueueExample {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1024);
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

        new Thread(producer).start();
        new Thread(consumer).start();

        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

下面是Producer类.注意咱们每调用一次put()就会让线程睡眠一秒.这会致使消费线程在队列中等待对象时发生阻塞.

public class Producer implements Runnable {
    private ArrayBlockingQueue<String> queue;

    public Producer(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            queue.put("1");
            Thread.sleep(1000);
            queue.put("2");
            Thread.sleep(1000);
            queue.put("3");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

下面是Consumer类.它只是负责从队列中取出字符串并经过System.out打印出来.

package org.menfre;

import java.util.concurrent.ArrayBlockingQueue;

public class Consumer implements Runnable {
    private ArrayBlockingQueue<String> queue;

    public Consumer(ArrayBlockingQueue<String> queue){
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            System.out.println(queue.take());
            System.out.println(queue.take());
            System.out.println(queue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

该系列博文为笔者复习基础所著译文或理解后的产物,复习原文来自Jakob Jenkov所著Java.util.concurrent

Next: ArrayBlockingQueue