HashMap HashTable和ConcurrentHashMap知识点大集合

1、实现原理以及数据结构

Java中数据存储方式最底层的两种结构，一种是数组，另一种就是链表，数组的特点：连续空间，寻址迅速，但是在删除或者添加元素的时候需要有较大幅度的移动，所以查询速度快，增删较慢。而链表正好相反，由于空间不连续，寻址困难，增删元素只需修改指针，所以查询慢、增删快。有没有一种数据结构来综合一下数组和链表，以便发挥他们各自的优势？答案是肯定的！就是：哈希表。哈希表具有较快（常量级）的查询速度，及相对较快的增删速度，所以很适合在海量数据的环境中使用。一般实现哈希表的方法采用“拉链法”，我们可以理解为“链表的数组”。

HashTable

1、底层数组+链表实现，无论key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低，ConcurrentHashMap做了相关优化

2、初始size为11，扩容：newsize = oldsize*2+1

3、计算index的方法：index = (hash & 0x7FFFFFFF) % tab.length

HashMap

1、底层数组+链表实现，可以存储null键和null值，线程不安全

2、初始size为16，扩容：newsize = oldsize*2，size一定为2的n次幂

3、扩容针对整个Map，每次扩容时，原来数组中的元素依次重新计算存放位置，并重新插入

4、插入元素后才判断该不该扩容，有可能无效扩容（插入后如果扩容，如果没有再次插入，就会产生无效扩容）

5、当Map中元素总数超过Entry数组的75%，触发扩容操作，为了减少链表长度，元素分配更均匀

6、计算index方法：index = hash & (tab.length – 1)

ConcurrentHashMap

1、底层采用分段的数组+链表实现，线程安全

2、通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)

源码如下,其中Segment继承ReentrantLock实现ConcurrentHashMap的线程安全，

static final class Segment extends ReentrantLock implements Serializable {
        private static final long serialVersionUID = 2249069246763182397L;
        transient volatile int count;
        transient int modCount;
        transient int threshold;
        transient volatile ConcurrentHashMap.HashEntry[] table;
        final float loadFactor;

        Segment(int var1, float var2) {
            this.loadFactor = var2;
            this.setTable(ConcurrentHashMap.HashEntry.newArray(var1));
        }

        static final  ConcurrentHashMap.Segment[] newArray(int var0) {
            return new ConcurrentHashMap.Segment[var0];
        }

        void setTable(ConcurrentHashMap.HashEntry[] var1) {
            this.threshold = (int)((float)var1.length * this.loadFactor);
            this.table = var1;
        }

        ConcurrentHashMap.HashEntry getFirst(int var1) {
            ConcurrentHashMap.HashEntry[] var2 = this.table;
            return var2[var1 & var2.length - 1];
        }

        V readValueUnderLock(ConcurrentHashMap.HashEntry var1) {
            this.lock();

            Object var2;
            try {
                var2 = var1.value;
            } finally {
                this.unlock();
            }

            return var2;
        }
}

3、Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术（即其Segment继承ReentrantLock累实现锁机制）

4、有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁

5、扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容

 

底层存储数据的entry区别：

HashMap

static class Entry implements java.util.Map.Entry {
        final K key;
        V value;
        HashMap.Entry next;
        final int hash;

        Entry(int var1, K var2, V var3, HashMap.Entry var4) {
            this.value = var3;
            this.next = var4;
            this.key = var2;
            this.hash = var1;
        }

        public final K getKey() {
            return this.key;
        }

        public final V getValue() {
            return this.value;
        }

        public final V setValue(V var1) {
            Object var2 = this.value;
            this.value = var1;
            return var2;
        }

        public final boolean equals(Object var1) {
            if(!(var1 instanceof java.util.Map.Entry)) {
                return false;
            } else {
                java.util.Map.Entry var2 = (java.util.Map.Entry)var1;
                Object var3 = this.getKey();
                Object var4 = var2.getKey();
                if(var3 == var4 || var3 != null && var3.equals(var4)) {
                    Object var5 = this.getValue();
                    Object var6 = var2.getValue();
                    if(var5 == var6 || var5 != null && var5.equals(var6)) {
                        return true;
                    }
                }

                return false;
            }
        }

        public final int hashCode() {
            return (this.key == null?0:this.key.hashCode()) ^ (this.value == null?0:this.value.hashCode());
        }

        public final String toString() {
            return this.getKey() + "=" + this.getValue();
        }

        void recordAccess(HashMap var1) {
        }

        void recordRemoval(HashMap var1) {
        }
    }

ConcurrentHashMap

static final class HashEntry {
        final K key;
        final int hash;
        volatile V value;
        final ConcurrentHashMap.HashEntry next;

        HashEntry(K var1, int var2, ConcurrentHashMap.HashEntry var3, V var4) {
            this.key = var1;
            this.hash = var2;
            this.next = var3;
            this.value = var4;
        }

        static final  ConcurrentHashMap.HashEntry[] newArray(int var0) {
            return new ConcurrentHashMap.HashEntry[var0];
        }
    }

ConcurrentHashMap 的value增加了volatile修饰符。

 

由上图可看出HashMap以及ConcurrentHashMap的内部构造。而ConcurrentHashMap是使用了锁分段技术来保证线程安全的。

锁分段技术：首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。 

ConcurrentHashMap提供了与Hashtable和SynchronizedMap不同的锁机制。Hashtable中采用的锁机制是一次锁住整个hash表，从而在同一时刻只能由一个线程对其进行操作；而ConcurrentHashMap中则是一次锁住一个桶。

ConcurrentHashMap默认将hash表分为16个桶，诸如get、put、remove等常用操作只锁住当前需要用到的桶。这样，原来只能一个线程进入，现在却能同时有16个写线程执行，并发性能的提升是显而易见的。