14个Java并发容器，你用过几个？

时间  2019-11-05
标签 java 并发 容器 用过 几个 栏目 Java 繁體版
原文   原文链接
做者：acupt

前言

不考虑多线程并发的状况下，容器类通常使用ArrayList、HashMap等线程不安全的类，效率更高。在并发场景下，常会用到ConcurrentHashMap、ArrayBlockingQueue等线程安全的容器类，虽然牺牲了一些效率，但却获得了安全。
上面提到的线程安全容器都在java.util.concurrent包下，这个包下并发容器很多，今天所有翻出来鼓捣一下。
仅作简单介绍，后续再分别深刻探索。

并发容器介绍

  1. ConcurrentHashMap：并发版HashMap
  2. CopyOnWriteArrayList：并发版ArrayList
  3. CopyOnWriteArraySet：并发Set
  4. ConcurrentLinkedQueue：并发队列(基于链表)
  5. ConcurrentLinkedDeque：并发队列(基于双向链表)
  6. ConcurrentSkipListMap：基于跳表的并发Map
  7. ConcurrentSkipListSet：基于跳表的并发Set
  8. ArrayBlockingQueue：阻塞队列(基于数组)
  9. LinkedBlockingQueue：阻塞队列(基于链表)
  10. LinkedBlockingDeque：阻塞队列(基于双向链表)
  11. PriorityBlockingQueue：线程安全的优先队列
  12. SynchronousQueue：读写成对的队列
  13. LinkedTransferQueue：基于链表的数据交换队列
  14. DelayQueue：延时队列

1.ConcurrentHashMap 并发版HashMap

最多见的并发容器之一，能够用做并发场景下的缓存。底层依然是哈希表，但在JAVA 8中有了不小的改变，而JAVA 7和JAVA 8都是用的比较多的版本，所以常常会将这两个版本的实现方式作一些比较（好比面试中）。
一个比较大的差别就是，JAVA 7中采用分段锁来减小锁的竞争，JAVA 8中放弃了分段锁，采用CAS（一种乐观锁），同时为了防止哈希冲突严重时退化成链表（冲突时会在该位置生成一个链表，哈希值相同的对象就链在一块儿），会在链表长度达到阈值（8）后转换成红黑树（比起链表，树的查询效率更稳定）。

2.CopyOnWriteArrayList 并发版ArrayList

并发版ArrayList，底层结构也是数组，和ArrayList不一样之处在于：当新增和删除元素时会建立一个新的数组，在新的数组中增长或者排除指定对象，最后用新增数组替换原来的数组。
适用场景：因为读操做不加锁，写（增、删、改）操做加锁，所以适用于读多写少的场景。
局限：因为读的时候不会加锁（读的效率高，就和普通ArrayList同样），读取的当前副本，所以可能读取到脏数据。若是介意，建议不用。
看看源码感觉下： 
public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    final transient ReentrantLock lock = new ReentrantLock();
    private transient volatile Object[] array;
    // 添加元素，有锁
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock(); // 修改时加锁，保证并发安全
        try {
            Object[] elements = getArray(); // 当前数组
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1); // 建立一个新数组，比老的大一个空间
            newElements[len] = e; // 要添加的元素放进新数组
            setArray(newElements); // 用新数组替换原来的数组
            return true;
        } finally {
            lock.unlock(); // 解锁
        }
    }
    // 读元素，不加锁，所以可能读取到旧数据
    public E get(int index) {
        return get(getArray(), index);
    }
}

复制代码

3.CopyOnWriteArraySet 并发Set

基于CopyOnWriteArrayList实现（内含一个CopyOnWriteArrayList成员变量），也就是说底层是一个数组，意味着每次add都要遍历整个集合才能知道是否存在，不存在时须要插入（加锁）。
适用场景：在CopyOnWriteArrayList适用场景下加一个，集合别太大（所有遍历伤不起）。

4.ConcurrentLinkedQueue 并发队列(基于链表)

基于链表实现的并发队列，使用乐观锁(CAS)保证线程安全。由于数据结构是链表，因此理论上是没有队列大小限制的，也就是说添加数据必定能成功。

5.ConcurrentLinkedDeque 并发队列(基于双向链表)

基于双向链表实现的并发队列，能够分别对头尾进行操做，所以除了先进先出(FIFO)，也能够先进后出（FILO），固然先进后出的话应该叫它栈了。

6.ConcurrentSkipListMap 基于跳表的并发Map

SkipList即跳表，跳表是一种空间换时间的数据结构，经过冗余数据，将链表一层一层索引，达到相似二分查找的效果

7.ConcurrentSkipListSet 基于跳表的并发Set

相似HashSet和HashMap的关系，ConcurrentSkipListSet里面就是一个ConcurrentSkipListMap，就不细说了。

8.ArrayBlockingQueue 阻塞队列(基于数组)

基于数组实现的可阻塞队列，构造时必须制定数组大小，往里面放东西时若是数组满了便会阻塞直到有位置（也支持直接返回和超时等待），经过一个锁ReentrantLock保证线程安全。
用offer操做举个例子： 
public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
    /**
     * 读写共用此锁，线程间经过下面两个Condition通讯
     * 这两个Condition和lock有紧密联系（就是lock的方法生成的）
     * 相似Object的wait/notify
     */
    final ReentrantLock lock;
    /** 队列不为空的信号，取数据的线程须要关注 */
    private final Condition notEmpty;
    /** 队列没满的信号，写数据的线程须要关注 */
    private final Condition notFull;
    // 一直阻塞直到有东西能够拿出来
    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }
    // 在尾部插入一个元素，队列已满时等待指定时间，若是仍是不能插入则返回
    public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {
        checkNotNull(e);
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly(); // 锁住
        try {
            // 循环等待直到队列有空闲
            while (count == items.length) {
                if (nanos <= 0)
                    return false;// 等待超时，返回
                // 暂时放出锁，等待一段时间（可能被提早唤醒并抢到锁，因此须要循环判断条件）
                // 这段时间可能其余线程取走了元素，这样就有机会插入了
                nanos = notFull.awaitNanos(nanos);
            }
            enqueue(e);//插入一个元素
            return true;
        } finally {
            lock.unlock(); //解锁
        }
    }

复制代码
乍一看会有点疑惑，读和写都是同一个锁，那要是空的时候正好一个读线程来了不会一直阻塞吗？
答案就在notEmpty、notFull里，这两个出自lock的小东西让锁有了相似synchronized + wait + notify的功能。

9.LinkedBlockingQueue 阻塞队列(基于链表)

基于链表实现的阻塞队列，想比与不阻塞的ConcurrentLinkedQueue，它多了一个容量限制，若是不设置默认为int最大值。

10.LinkedBlockingDeque 阻塞队列(基于双向链表)

相似LinkedBlockingQueue，但提供了双向链表特有的操做。

11.PriorityBlockingQueue 线程安全的优先队列

构造时能够传入一个比较器，能够看作放进去的元素会被排序，而后读取的时候按顺序消费。某些低优先级的元素可能长期没法被消费，由于不断有更高优先级的元素进来。

12.SynchronousQueue 数据同步交换的队列

一个虚假的队列，由于它实际上没有真正用于存储元素的空间，每一个插入操做都必须有对应的取出操做，没取出时没法继续放入。
一个简单的例子感觉一下： 
import java.util.concurrent.*;
public class Main {
    public static void main(String[] args) {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();
        new Thread(() -> {
            try {
                // 没有休息，疯狂写入
                for (int i = 0; ; i++) {
                    System.out.println("放入: " + i);
                    queue.put(i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            try {
                // 咸鱼模式取数据
                while (true) {
                    System.out.println("取出: " + queue.take());
                    Thread.sleep((long) (Math.random() * 2000));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}
/* 输出:
放入: 0
取出: 0
放入: 1
取出: 1
放入: 2
取出: 2
放入: 3
取出: 3
*/

复制代码
能够看到，写入的线程没有任何sleep，能够说是全力往队列放东西，而读取的线程又很不积极，读一个又sleep一会。输出的结果倒是读写操做成对出现。
JAVA中一个使用场景就是Executors.newCachedThreadPool()，建立一个缓存线程池。 
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(
        0, // 核心线程为0，没用的线程都被无情抛弃
        Integer.MAX_VALUE, // 最大线程数理论上是无限了，还没到这个值机器资源就被掏空了
        60L, TimeUnit.SECONDS, // 闲置线程60秒后销毁
        new SynchronousQueue<Runnable>()); // offer时若是没有空闲线程取出任务，则会失败，线程池就会新建一个线程
}

复制代码

13.LinkedTransferQueue 基于链表的数据交换队列

实现了接口TransferQueue，经过transfer方法放入元素时，若是发现有线程在阻塞在取元素，会直接把这个元素给等待线程。若是没有人等着消费，那么会把这个元素放到队列尾部，而且此方法阻塞直到有人读取这个元素。和SynchronousQueue有点像，但比它更强大。

14.DelayQueue 延时队列

可使放入队列的元素在指定的延时后才被消费者取出，元素须要实现Delayed接口。

总结

上面简单介绍了JAVA并发包下的一些容器类，知道有这些东西，遇到合适的场景时就能想起有个现成的东西能够用了。想要知其因此然，后续还得再深刻探索一番。

最后

欢迎你们关注个人公众号【程序员追风】，文章都会在里面更新，整理的资料也会放在里面。
java

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程