浅析ConcurrentHashMap和HashMap的线程安全问题

明小天666
350 阅读4分钟

在日常开发中经常会使用HashMap，但是在多线程情景下，HashMap是线程不安全的；为了避免线程安全问题，推荐大家使用ConcurrentHashMap，下面就根据源码分析一下ConcurrentHashMap为什么能保证线程安全，HashMap为什么线程不安全；

ConcurrentHashMap的基本属性

以下代码为JDK1.8中的ConcurrentHashMap

首先看下ConcurrentHashMap的基本属性：底层数据结构是 数组 + 链表 + 红黑树，数组默认大小是16，链表为单向链表，默认扩容负载因子为0.75f，以及一些红黑树的相关属性，大致和HashMap类似；

// Node数组
transient volatile Node<K,V>[] table;

// 扩容时使用
private transient volatile Node<K,V>[] nextTable;

// 单向链表
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;
}

// 最大容量为2的30次幂（和HashMap一样，容量必须为2的n次幂）
private static final int MAXIMUM_CAPACITY = 1 << 30;

// 默认容量
private static final int DEFAULT_CAPACITY = 16;

// 默认负载因子，与扩容有关
private static final float LOAD_FACTOR = 0.75f;

// 链表转变红黑树条件一需要链表长度大于等于8
static final int TREEIFY_THRESHOLD = 8;

// 链表转变红黑树条件二需要数组长度大于等于64（条件一和条件二需要同时满足）
static final int MIN_TREEIFY_CAPACITY = 64;

// 红黑树转变为单链表需要链表长度小于等于6
static final int UNTREEIFY_THRESHOLD = 6;

HashMap为什么线程不安全？

以下代码为JDK1.8中的HashMap的putVal方法;

如需对HashMap感兴趣，可以阅读这篇文章浅析HashMap源码

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 1：当多个线程都执行到这个地方并且计算得出的数组位置相同时，会导致数据覆盖
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 计算出的数组位置相同时，出现数据覆盖，导致数据丢失
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                // 2：当多个线程同时在数组的同一个位置出现冲突时，尾插法导致数据覆盖，数据丢失
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
        }
    }
    ++modCount;
    // 3：size加1的操作不具有原子性，多线程情景下可能会导致size少加1，从而使size变小
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

从上述代码中我们可以知道大概有三个地方（注释上有标记序号）可能会导致线程安全：

  1. 当多个线程同时判断数组的同一个位置没有存储值时，会执行数组的赋值操作，这就会导致先前线程的值被后一个线程的值覆盖，导致前一个线程的数据丢失（这里需要满足 多个线程同时要往数组同一个没有元素的位置添加元素 才会导致线程安全问题）；
  2. 当多个线程同时往数组的同一个位置的链表尾部添加新元素时，会导致数据覆盖，数据丢失；
  3. ++size这种操作不具有原子性，多线程的情景下可能会导致size的值不准确，导致值偏小；

ConcurrentHashMap为什么线程安全？

以下代码为JDK1.8中的ConcurrentHashMap的putVal方法

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 1：通过CAS操作保证多个线程同时往数组同一个位置中添加元素时，只有一个线程能添加成功
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 2：通过synchronized关键字加锁保证添加元素时线程安全
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 3：方法内部也是通过CAS保证线程安全
    addCount(1L, binCount);
    return null;
}

从上述代码中我们可以知道大概有三个地方（注释上有标记序号）用于保证线程安全：

  1. 多个线程同时往数组同一个没有元素的位置中添加元素时，通过CAS操作保证只有一个线程能添加成功；
  2. 通过synchronized关键字加锁保证添加元素时线程安全，其中锁的对象是链表的头节点，这样可以在某个链表头节点被锁住时，不影响其他头节点的插入操作，效率更高；
  3. 通过CAS来保证线程安全

HashMap和ConcurrentHashMap的区别

下面说一下HashMap和ConcurrentHashMap的几个区别

  1. HashMap是线程不安全的，ConcurrentHashMap是线程安全的；

  2. HashMap允许Key和value为null，而ConcurrentHashMap不允许key和value为null;下面简单说一下原因，不允许value为null的原因是：如果value可以为null，在多线程环境下会引起歧义，无法确定是该位置没有元素还是有元素但是value是null，详细解答请阅读：stackoverflow.com/questions/6… 这里有jdk作者Doug Lea的回答；

  3. HashMap和ConcurrentHashMap的计算key的Hash值算法也是不同的;

    感谢大家的阅读，如您在阅读过程中有什么疑问或者发现了什么错误，请您在评论区留言，大家一起交流与学习。
avatar
文章
阅读
粉丝