java.util.concurrent – Java 并发工具包

翻译自http://tutorials.jenkov.com/java-util-concurrent/index.html

java.util.concurrent - Java 并发工具包二

Java 5 添加了一个新java包到Java平台，java.util.concurrent。这个包含有一系列的类使通过Java来开发并发（多线程）应用程序更为简单方便。在这个包被添加前你不得不自己创建相关工具类。

一、BlockingQueue 阻塞队列

java.util.concurrent里面的BlockingQueue接口代表一个线程安全的队列。
BlockingQueue通常用于一个线程生成对象，另一个线程消费。

生产线程持续生成新的对象并且把它插入都队列直到队列达到它容纳的上限。如果这个阻塞队列达到容量上限，生产线程再尝试插入新的对象时会阻塞。它会一直阻塞直到一个消费线程从队列中取走一个对象。

消费线程会持续从阻塞队列中取出对象然后处理它们。如果一个消费线程尝试从一个空的队列中取对象，它就会被阻塞直到一个生产线程向队列中放入一个对象为止。

1.1 BlockingQueue方法

BlockingQueue有4套不同的方法集合来插入、删除；2套方法来检查队列中的元素。每套不同方法的行为取决于请求的操作是否立即执行。这4套方法的区别是：

Throws Exception 如果企图的操作不可能立即完成，那么会抛出一个异常。
Special Value 如果企图的操作不可能立即完成，那么会返回一个特殊的值（通常是true/false）。
Blocks 如果企图的操作不可能立即完成，这个方法会阻塞，直到可以继续进行。
Times Out 如果企图的操作不可能立即完成，这个方法会阻塞，但是阻塞的时间最长不会超过指定的timeout值，达到timeout后会返回一个特殊的值（通常是true/false）来告诉你操作是否成功。

向BlockingQueue插入null是不可能的。如果你尝试去插入一个null，BlockingQueue会抛出NullPointerException。

也可以去获得BlockingQueue里所有的元素，而不仅仅是在队首或者队尾的元素。举个例子，你将一个对象入队后，但是你的程序决定要取消这个操作，这样你就可以使用比如：remove(o)这个方法来移除这个特殊的对象。但是这样的操作效率不高，所以你不应该用这些Collection方法除非你确实需要。

1.2 BlockingQueue实现

既然BlockingQueue是一个接口，你在实际使用中需要使用它的某个是实现。BlockingQueue接口有以下几个实现类（在Java 6）：

ArrayBlockingQueue
DelayQueue
LinkedBlockingQueue
PriorityBlockingQueue
SynchronousQueue

1.2.1 ArrayBlockingQueue

ArrayBlockingQueue是一个有边界的连续的队列，在内部是通过一个数组存储元素的。有边界意味着它不能无限制的存储元素。同时在实例化时需要指定存储的元素个数，一旦实例化完成这个上限不可修改。

ArrayBlockingQueue存储元素遵循FIFO（先进先出）顺序。示例：

BlockingQueue queue = new ArrayBlockingQueue(1024);
queue.put("1");
Object object = queue.take();

// 或者使用泛型
BlockingQueue queue = new ArrayBlockingQueue(1024);
queue.put("1");
String string = queue.take();

1.2.2 DelayQueue

DelayQueue内部会阻塞元素直到一个确定的延迟过期后。队列里的元素必须实现java.util.concurrent.Delayed接口，下面就是这个接口：

public interface Delayed extends Comparable


getDelay()方法返回的值是在这个元素可以被释放前延迟剩余的时间。如果0或者一个负数被返回了，延迟时间会被认为已经过期，这个元素将会在下一个调用队列的take()等取出方法时被释放。
1.2.3 LinkedBlockingQueue
LinkedBlockingQueue实现了BlockingQueue接口。它内部保存元素采用了一种链式结构（链式节点）。这种链式结构如果需要可选择性设置上限。如果没有指定上限，Integer.MAX_VALUE将会被作为上限。
LinkedBlockingQueue存储元素时遵循FIFO(First In, First Out)的顺序。
下面是相关示例：
BlockingQueue unbounded = new LinkedBlockingQueue();
BlockingQueue bounded   = new LinkedBlockingQueue(1024);

bounded.put("Value");

String value = bounded.take();

1.2.4 PriorityBlockingQueue
PriorityBlockingQueue是一个无界的并发队列。它使用与java.util.PriorityQueue相同的排序规则。你不能插入null到这个队列。插入到PriorityBlockingQueue的所有元素必须实现java.lang.Comparable接口。元素根据你在Comparable实现里决定的优先级排列它们自己。
注意PriorityBlockingQueue对于有相同的优先级(compare() == 0)的元素没有强迫任何特殊的行为。
还应该注意，假如你从PriorityBlockingQueue获得到一个Iterator，这个Iterator没有保证在优先级顺序下遍历元素。
这里是一个示例：
BlockingQueue queue   = new PriorityBlockingQueue();

//String实现了java.lang.Comparable
queue.put("Value");

String value = queue.take();

1.2.5 SynchronousQueue
SynchronousQueue队列内部只能容纳一个元素。一个线程如果插入一个元素到这个队列就会阻塞，知道另一个线程从队列中取出。类似的，如果一个线程尝试取出一个元素但是队列里面现在没有元素，这个线程就会被阻塞直到一个线程插入一个元素到队列。
1.3 BlockingQueue示例
生产者类。注意每个put()之间的线程休眠的时间，在消费者等待从队列中取对象时将会引起阻塞。
public class Producer implements Runnable{

    protected BlockingQueue queue = null;

    public Producer(BlockingQueue queue) {
        this.queue = queue;
    }

    public void run() {
        try {
            queue.put("1");
            Thread.sleep(1000);
            queue.put("2");
            Thread.sleep(1000);
            queue.put("3");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

下面是消费者类。它只是从队列中取出对象并使用System.out打印它们。
public class Consumer implements Runnable{

    protected BlockingQueue queue = null;

    public Consumer(BlockingQueue queue) {
        this.queue = queue;
    }

    public void run() {
        try {
            System.out.println(queue.take());
            System.out.println(queue.take());
            System.out.println(queue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

BlockingQueueExample类会分别开启一个生产者类和一个消费者类的线程。生产者向一个共享的BlockingQueue插入字符串，同时消费者类从中取出。
public class BlockingQueueExample {

    public static void main(String[] args) throws Exception {

        BlockingQueue queue = new ArrayBlockingQueue(1024);

        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

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

        Thread.sleep(4000);
    }
}

二、BlockingDeque 阻塞双端队列
BlockingDeque接口代表一个双端队列，它对于插入与取出的操作都是线程安全的。
2.1 BlockingDeque使用
BlockingDeque可以这样被使用，如果所有线程都同时既生产也消费同一个队列的元素。也同样适用于生产线程需要在队列两端插入，消费线程需要从队列两端取出。








一个线程生产元素并且可以将它们插入队列的两端。如果双端队列当前是满的，这个插入线程将会被阻塞直到一个消费线程从队列取出一个元素，当消费线程从中取的时候也是类似的情况。
2.2 BlockingDeque方法
BlockingDeque有4种不同系列的方法用来插入、删除和检查在双端队列中的元素。








这四套不同的行为如下，与BlockingQueue类似：

Throws Exception 如果企图的操作不可能立即完成，那么会抛出一个异常。
Special Value 如果企图的操作不可能立即完成，那么会返回一个特殊的值（通常是true/false）。
Blocks 如果企图的操作不可能立即完成，这个方法会阻塞，直到可以继续进行。
Times Out 如果企图的操作不可能立即完成，这个方法会阻塞，但是阻塞的时间最长不会超过指定的timeout值，达到timeout后会返回一个特殊的值（通常是true/false）来告诉你操作是否成功。

2.3 BlockingDeque继承自BlockingQueue
BlockingDeque接口继承自BlockingQueue接口。这意味这你可以将BlockingDeque当作BlockingQueue用。
下面是一个表格来展示BlockingQueue的方法在BlockingDeque的实现里是如何工作的：








2.4 BlockingDeque实现类
既然BlockingDeque是一个接口，你就需要使用它的某个实现类。java.util.concurrent包有以下实现类：
LinkedBlockingDeque
2.5 BlockingDeque代码示例
下面是一个简单的例子来展示如何使用它的方法：
BlockingDeque deque = new LinkedBlockingDeque();

deque.addFirst("1");
deque.addLast("2");

String two = deque.takeLast();
String one = deque.takeFirst();

java.util.concurrent – Java 并发工具包

一、BlockingQueue 阻塞队列

1.1 BlockingQueue方法

1.2 BlockingQueue实现

1.2.1 ArrayBlockingQueue

1.2.2 DelayQueue

1.2.3 LinkedBlockingQueue

1.2.4 PriorityBlockingQueue

1.2.5 SynchronousQueue

1.3 BlockingQueue示例

二、BlockingDeque 阻塞双端队列

2.1 BlockingDeque使用

2.2 BlockingDeque方法

2.3 BlockingDeque继承自BlockingQueue

2.4 BlockingDeque实现类

2.5 BlockingDeque代码示例

你可能感兴趣的:(java.util.concurrent – Java 并发工具包)