Java多线程专题-并发队列

在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。

 

ConcurrentLinkedQueue

是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue。它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的，尾是最近加入的，该队列不允许null元素。

ConcurrentLinkedQueue重要方法:

• add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)
• poll() 和peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。

BlockingQueue

BlockingQueue即阻塞队列，从阻塞这个词可以看出，在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种：

1. 当队列满了的时候进行入队列操作
2. 当队列空了的时候进行出队列操作

因此，当一个线程试图对一个已经满了的队列进行入队列操作时，它将会被阻塞，除非有另一个线程做了出队列操作；同样，当一个线程试图对一个空队列进行出队列操作时，它将会被阻塞，除非有另一个线程进行了入队列操作。

在Java中，BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供)，由上面介绍的阻塞队列的特性可知，阻塞队列是线程安全的。

• ArrayBlockingQueue: 通过数组实现的有边界的阻塞队列
• LinkedBlockingQueue: 可配置边界大小，不配置则无边界，通过链表实现
• PriorityBlockingQueue: 无边界有序的队列，元素必须实现Comparable接口
• SynchronousQueue: 仅可容纳一个元素

ArrayBlockingQueue

ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。有边界的意思是它的容量是有限的，我们必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。

ArrayBlockingQueue是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。

LinkedBlockingQueue

LinkedBlockingQueue阻塞队列大小的配置是可选的，如果我们初始化时指定一个大小，它就是有边界的，如果不指定，它就是无边界的。说是无边界，其实是采用了默认大小为Integer.MAX_VALUE的容量 。它的内部实现是一个链表。

和ArrayBlockingQueue一样，LinkedBlockingQueue 也是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。

​​​​​​​PriorityBlockingQueue

PriorityBlockingQueue是一个没有边界的队列，它的排序规则和 java.util.PriorityQueue一样。需要注意，PriorityBlockingQueue中允许插入null对象。

所有插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口，队列优先级的排序规则就是按照我们对这个接口的实现来定义的。

另外，我们可以从PriorityBlockingQueue获得一个迭代器Iterator，但这个迭代器并不保证按照优先级顺序进行迭代。

​​​​​​​SynchronousQueue

SynchronousQueue队列内部仅允许容纳一个元素，但不会单独单独保存这个元素。当一个线程插入一个元素时会被阻塞，除非这个元素被另一个线程消费，如果一个线程获取元素时也会被阻塞，需要等到其他线程插入元素。

生产者与消费者案例

class Producer extends Thread {
    private BlockingQueue<String> queue;
    private AtomicInteger count = new AtomicInteger(0);
    private boolean flag = true;

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

    @Override
    public void run() {
        System.out.println("生产线程启动...");
        while (flag) {
            String data = count.incrementAndGet() + "";
            System.out.println("已生产数据：" + data);
            try {
                boolean offer = queue.offer(data, 2, TimeUnit.SECONDS);
                if (offer) {
                    System.out.println("成功加入队列：" + data);
                } else {
                    System.out.println("加入队列失败：" + data);
                }
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("生产线程停止...");
    }

    public void stopThread() {
        flag = false;
    }
}

class Customer extends Thread {
    private BlockingQueue<String> queue;
    private boolean flag = true;

    public Customer(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        System.out.println("消费线程启动...");
        try {
            while (flag) {
                String data = queue.poll(2, TimeUnit.SECONDS);
                if(data != null){
                    System.out.println("已消费数据：" + data + ",剩余：" + queue.size());
                }else{
                    System.out.println("消费数据失败：" + data);
                    flag = false;    
                }
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("消费线程停止...");
    }
}

public class ThreadDemo4 {
    public static void main(String[] args) throws Exception {
        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(10);
        Producer producer1 = new Producer(queue);
        Producer producer2 = new Producer(queue);
        Customer customer = new Customer(queue);
        producer1.start();
        producer2.start();
        customer.start();
        Thread.sleep(20000);
        producer1.stopThread();
        producer2.stopThread();
    }
}