ConcurrentHashMap

一. 引言

HashMap众所周知底层是基于数组+链表组成的,不过在jdk1.7和1.8中具体实现稍有不不同,

二. Java1.7

上图是HashMap中的比较核心的几个成员变量

1. 初始化容器大小,因为底层是数组,所以这是数组默认大小
2. 容器最大值
3. 默认的负载因子(0.75)
4. table真正存放数据的数组
5. map存放数量的大小
6. 容器大小,可在初始化时显示指定
7. 负载因子,可在初始化显示指定

负载因子

因为hashMap的容量大小是固定的,比如默认初始化:

    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                    initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                    loadFactor);

        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        init();
    }

给定的默认容量为16,负载因子为0.75。Map在使用过程中不断的往里面存放数据,当数量达到了16 * 0.75 = 12就需要将当前16的容器进行扩容,而扩容这个过程涉及到rehash,赋值数据等操作,所以非常消耗性能.因此通常建议能提前预估HashMap的大小对号,尽量减少扩容带来的性能损耗
根据代码可以看出其真正存放数据的是
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

那么这个Entry数组是如何定义的呢?

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
        int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

从代码可以看出

• key，value：是添加的值
• next：因为是由数组和链表组成，这个next用于实现链表结构用的
• hash存放的事当前key的hashcode(是由一个hash(key)方法计算来的)

put方法

    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

• 判断当前数组是否需要初始化
• 判断key是否等于空,如果等于放一个空值进去
• int hash = hash(key);根据key计算出hashcode
• int i = indexFor(hash, table.length);根据计算出的hashcode定位出所在容器
• 如果容器是一个链表则需要遍历判断里面的hashcode,key是否和传入的key相等,如果相等则进行覆盖,并返回原来的值
• addEntry(hash, key, value, i);如果容器时空的,说明当前位置没有数据存入;新增一个Entry对象写入当前位置

addEntry/createEntry

    void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        createEntry(hash, key, value, bucketIndex);
    }

    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K, V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

• 当调用addEntry写入Entry时需要判断是否需要扩容
• 如果需要就进行练呗扩容,并将当前的key重新hash并定位
• create中会将当前位置的容器传入到新建的容器中,如果当前容器有值就会在位置形成链表

get方法

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K, V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

    final Entry<K, V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K, V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

• 首先也是根据key计算出hashcode,然后定位到具体的容器中
• 判断该位置是否为链表
• 不是链表就根据key,key的hashcode是否相等来返回值
• 是链表则需要遍历知道key及hashcode相等时候就返回值
• 啥都没取到就直接返回null

三. Java1.8

我们不一样

1.7当Hash冲突严重时,在容器上形成的链会变得越来越长,这样在查询的效率会越来越低;时间复杂度为0(n)

在1.8的时候优化了查询效率,加入了红黑树

这是核心成员变量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

   /**
    * The load factor used when none specified in constructor.
    */
   static final float DEFAULT_LOAD_FACTOR = 0.75f;

   static final int TREEIFY_THRESHOLD = 8;

   transient Node<K,V>[] table;

   /**
    * Holds cached entrySet(). Note that AbstractMap fields are used
    * for keySet() and values().
    */
   transient Set<Map.Entry<K,V>> entrySet;

   /**
    * The number of key-value mappings contained in this map.
    */
   transient int size;

TREEIFY_THRESHOLD是用来判断是否需要将链表转换为红黑树的阈值
HashEntry修改为Node
Node的核心跟1.7的hashEntry一样,存放的都是key value hashcode next等数据.

put方法

是不是感觉多了好多东西,更没有耐心读下去了,别急,一步步都有解释

1. 判断当前容器是否为空,空的就要初始化.
2. 根据当前key的hashcode定位到具体的容器中并判断是否为空,为空表名没有hash冲突就直接在当前位置创建一个新容器即可
3. 如果当前有值(hash冲突),那么就要比较当前容重的key,key中的hashcode与写入的key是否相等,相等就赋值给e,在第8步会同一进行赋值及返回
4. 如果当前容器为红黑树,那就要按照红黑树的方式写入数据
5. 如果是个链表,就需要将当前的key,value封装成一个新节点写入到当前容器后面(形成链表)
6. 接着判断当前链表的大小是否大于预设阈值,大于时就要转换为红黑树
7. 如果在遍历过程中找到相同的key直接退出遍历
8. 如果e != null 就相当于存在相同的key,那就需要将值覆盖
9. 最后判断是否需要进行扩容

get方法

public V get(Object key) {
        Node<K, V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    final Node<K, V> getNode(int hash, Object key) {
        Node<K, V>[] tab;
        Node<K, V> first, e;
        int n;
        K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
                (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                    ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K, V>) first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

• 首先将key,hash之后取得所定位的容器
• 如果通为空则直接返回null
• 否则判断容器的第一个位置(有可能是链表,红黑树)的key是否查询的key,是就直接返回value
• 如果第一个不匹配,则判断它的下一个是红黑树还是链表.
• 红黑树就按照树的方式返回值
• 不然就按照链表的方式遍历匹配返回值

这两个核心方法(get/put)可以看出1.8中对大链表做了优化,修改红黑树之后查询效率直接提高到了O(logn)

四. ConcurrentHashMap和HashMap的区别

HashMap不是线程安全的
ConcurrentHashMap是线程安全的

ConcurrentHashMap是怎样实现线程安全的呢,肯定不可能是每个方法都价格Synchronized,那样就变成了HashTable

从ConcurrentHashMap代码可以看出,她引入了一个叫"分段锁"的概念具体可以理解为吧一个大的Map拆分陈N个小的HashTable,根据key.hashCode()来决定吧key放到哪个hashTable中

既然不能全锁（HashTable）又不能不锁（HashMap），所以就搞个部分锁，只锁部分，用到哪部分就锁哪部分。看到网上有个比喻:一个大仓库，里面有若干个隔间，每个隔间都有锁，同时只允许一个人进隔间存取东西。但是，在存取东西之前，需要有一个全局索引，告诉你要操作的资源在哪个隔间里，然后当你看到隔间空闲时，就可以进去存取，如果隔间正在占用，那你就得等着。

1.7和1.8结构区别

• 1.7
  如图所示是由Segment数组,HashEntry组成,和HashMap一样仍然是数组加链表
  

• 1.8
  这个图更刚才的是不是很像,他们的结构其实是类似的
  其中抛弃了原有的Segment分段所,采用了CAS + synchronized来保证并发安全性,其中存放数据的HashEntry改为Node但是作用是相同的
  

1.7和1.8Put方法区别

1.7

put方法

1. 将当前Segment中的table通过key的hashcode定位到HashEntry
2. 遍历该HashEntry,如果不为空则判断传入的key和当前遍历的key是否相等,相等则覆盖旧的value
3. 不为空则需要新建一个HashEntry并加入到Segment中,同时会判断是否需要扩容
4. 最后会接入1中所获取当前Segment的锁

get方法

get逻辑比较简单,只需要将Key通过hash
zhihou dignwei dao jvti de Segment,再通过一次Hash定位到具体元素上.由于HashEntry中的value属性是volatile 关键词修饰的,保证了内存可见性,所以每次获取时都是最新值ConcurrentHashMap的get方法是非常搞笑的,因为整个过程都不需要加锁

1.8

put方法

1. 根据key计算出hashcode
2. 判断是否需要进行初始化
3. 找出用key定位出的Node,如果为空表示当前位置可以写入数据,利用CAS尝试写入,失败则自选保证成功
4. 判断是否需要扩容,需要则则进行扩容
5. 如果都不满足,则利用synchronied锁写入数据
6. 如果数量大于红黑树阈值(8),则要转换为红黑树

get方法

• 根据计算出来的hashcode寻址,如果找到那么直接返回值
• 如果是红黑树就按照数的方式获取值
• 都不满足就按照链表方式获取值