2.2 HashMap 线程不安全，HashTable 线程安全，LinkedHashMap

一、HashMap 线程不安全

初始化：构造一个空的HashMap，初始容量为16，负载因子为0.75

https://www.jianshu.com/p/dde9b12343c1

(1.7 Entry<K,V>头插法  1.8Node<K,V>尾插法)

扩容：通过HashMap源码可以看到是在put操作时，即向容器中添加元素时，判断当前容器中元素的个数是否达到阈值（当前数组长度乘以加载因子的值）的时候，就要自动扩容了。 其实就是重新计算容量；而这个扩容是计算出所需容器的大小之后重新定义一个新的容器，将原来容器中的元素放入其中。

设定threshold。 这个threshold = capacity * load factor 。当HashMap的size到了threshold时，就要进行resize，也就是扩容。

tableSizeFor()的主要功能是返回一个比给定整数大且最接近的2的幂次方整数，如给定10，返回2的4次方16.

注：hash 冲突发生的几种情况：

1.两节点key 值相同（hash值一定相同），导致冲突；

2.两节点key 值不同，由于 hash 函数的局限性导致hash 值相同，冲突；

3.两节点key 值不同，hash 值不同，但 hash 值对数组长度取模后相同，冲突；

//实现put和相关方法。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

boolean evict) {

Node<K,V>[] tab; Node<K,V> p; int n, i;

//如果table为空或者长度为0，则resize()

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length;

//确定插入table的位置，算法是(n - 1) & hash，在n为2的幂时，相当于取摸操作。

////找到key值对应的槽并且是第一个，直接加入

if ((p = tab[i = (n - 1) & hash]) == null)

tab[i] = newNode(hash, key, value, null);

//在table的i位置发生碰撞，有两种情况，1、key值是一样的，替换value值，

//2、key值不一样的有两种处理方式：2.1、存储在i位置的链表；2.2、存储在红黑树中

else {

Node<K,V> e; K k;

//第一个node的hash值即为要加入元素的hash

if (p.hash == hash &&

((k = p.key) == key || (key != null && key.equals(k))))

e = p;

//2.2

else if (p instanceof TreeNode)

e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

//2.1

else {

//不是TreeNode,即为链表,遍历链表

for (int binCount = 0; ; ++binCount) {

///链表的尾端也没有找到key值相同的节点，则生成一个新的Node,

//并且判断链表的节点个数是不是到达转换成红黑树的上界达到，则转换成红黑树。

if ((e = p.next) == null) {

// 创建链表节点并插入尾部

p.next = newNode(hash, key, value, null);

////超过了链表的设置长度8就转换成红黑树

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;

}

}

//如果e不为空就替换旧的oldValue值

if (e != null) { // existing mapping for key

V oldValue = e.value;

if (!onlyIfAbsent || oldValue == null)

e.value = value;

afterNodeAccess(e);

return oldValue;

}

}

++modCount;

if (++size > threshold)

resize();

afterNodeInsertion(evict);

return null;

}

 

1.7和1.8的HashMap的不同点

（1）JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法，那么为什么要这样做呢？因为JDK1.7是用单链表进行的纵向延伸，当采用头插法就是能够提高插入的效率，但是也会容易出现逆序且环形链表死循环问题。但是在JDK1.8之后是因为加入了红黑树使用尾插法，能够避免出现逆序且链表死循环的问题。

（2）扩容后数据存储位置的计算方式也不一样：

1. 在JDK1.7的时候是直接用hash值和需要扩容的二进制数进行&（这里就是为什么扩容的时候为啥一定必须是2的多少次幂的原因所在，因为如果只有2的n次幂的情况时最后一位二进制数才一定是1，这样能最大程度减少hash碰撞）（hash值 & length-1） 。
2. 而在JDK1.8的时候直接用了JDK1.7的时候计算的规律，也就是扩容前的原始位置+扩容的大小值=JDK1.8的计算方式，而不再是JDK1.7的那种异或的方法。但是这种方式就相当于只需要判断Hash值的新增参与运算的位是0还是1就直接迅速计算出了扩容后的储存方式。

（3）JDK1.7的时候使用的是数组+ 单链表的数据结构。但是在JDK1.8及之后时，使用的是数组+链表+红黑树的数据结构（当链表的深度达到8的时候，也就是默认阈值，就会自动扩容把链表转成红黑树的数据结构来把时间复杂度从O（N）变成O（logN）提高了效率）。

HashMap为什么是线程不安全的？

HashMap 在并发时可能出现的问题主要是两方面：

1. put的时候导致的多线程数据不一致
   比如有两个线程A和B，首先A希望插入一个key-value对到HashMap中，首先计算记录所要落到的 hash桶的索引坐标，然后获取到该桶里面的链表头结点，此时线程A的时间片用完了，而此时线程B被调度得以执行，和线程A一样执行，只不过线程B成功将记录插到了桶里面，假设线程A插入的记录计算出来的 hash桶索引和线程B要插入的记录计算出来的 hash桶索引是一样的，那么当线程B成功插入之后，线程A再次被调度运行时，它依然持有过期的链表头但是它对此一无所知，以至于它认为它应该这样做，如此一来就覆盖了线程B插入的记录，这样线程B插入的记录就凭空消失了，造成了数据不一致的行为。
2. resize而引起死循环
   这种情况发生在HashMap自动扩容时，当2个线程同时检测到元素个数超过 数组大小 × 负载因子。此时2个线程会在put()方法中调用了resize()，两个线程同时修改一个链表结构会产生一个循环链表（JDK1.7中，会出现resize前后元素顺序倒置的情况）。接下来再想通过get()获取某一个元素，就会出现死循环。

HashMap和HashTable的区别

HashMap和Hashtable都实现了Map接口，但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有：线程安全性，同步(synchronization)，以及速度。

1. HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受null(HashMap可以接受为null的键值(key)和值(value)，而Hashtable则不行)。
2. HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好。
3. 另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。
4. 由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
5. HashMap不能保证随着时间的推移Map中的元素次序是不变的。

需要注意的重要术语：

1. sychronized意味着在一次仅有一个线程能够更改Hashtable。就是说任何线程要更新Hashtable时要首先获得同步锁，其它线程要等到同步锁被释放之后才能再次获得同步锁更新Hashtable。
2. Fail-safe和iterator迭代器相关。如果某个集合对象创建了Iterator或者ListIterator，然后其它的线程试图“结构上”更改集合对象，将会抛出ConcurrentModificationException异常。但其它线程可以通过set()方法更改集合对象是允许的，因为这并没有从“结构上”更改集合。但是假如已经从结构上进行了更改，再调用set()方法，将会抛出IllegalArgumentException异常。
3. 结构上的更改指的是删除或者插入一个元素，这样会影响到map的结构。

HashMap可以通过下面的语句进行同步：

Map m = Collections.synchronizeMap(hashMap);

 

1.1 HashMap()

// 1.无参构造方法、

// 构造一个空的HashMap，初始容量为16，负载因子为0.75

public HashMap() {

this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted

}

无参构造方法就没什么好说的了。

1.2 HashMap(int initialCapacity)

2.构造一个初始容量为initialCapacity，负载因子为0.75的空的HashMap，

public HashMap(int initialCapacity) {

this(initialCapacity, DEFAULT_LOAD_FACTOR);

}

HashMap(int initialCapacity) 这个构造方法调用了1.3中的构造方法。

1.3 HashMap(int initialCapacity, float loadFactor)

// 3.构造一个空的初始容量为initialCapacity，负载因子为loadFactor的HashMap

 

 

//最大容量

//static final int MAXIMUM_CAPACITY = 1 << 30;

当指定的初始容量< 0时抛出IllegalArgumentException异常，当指定的初始容量> MAXIMUM_CAPACITY时，就让初始容量 = MAXIMUM_CAPACITY。当负载因子小于0或者不是数字时，抛出IllegalArgumentException异常。

设定threshold。 这个threshold = capacity * load factor 。当HashMap的size到了threshold时，就要进行resize，也就是扩容。

tableSizeFor()的主要功能是返回一个比给定整数大且最接近的2的幂次方整数，如给定10，返回2的4次方16.

遍历

没法通过索引获取所以不能用for循环

可以用增强for循环 hashMap.entrySet();的时候new EntrySet(),里面有foreach循环遍历map

或者 hashMap.entrySet().iterator() 返回EntryIterator()extends HashIterator()

里面的next() 调用了HashIterator的nextNode()

 

 二、HashTable  线程安全

1.数据结构

    

Hashtable底层是通过数组加链表来实现的。(Entry<K,V>)

 

 

2.初始化(初始化容量11)

    Hashtable并没有太多的常量，比如默认容量大小都是直接写在代码中，而没使用常量。

    从它的构造函数我们可以知道，Hashtable默认capacity是11，默认负载因子是0.75.

     它的key、value都不可以为null。

 

3.扩容

     hash数组默认大小是11，扩充方式是old*2+1

    

4.线程安全性

    线程安全（concurrenthashmap更好）

5.遍历

6.插入删除

    Hashtable是在链表的头部添加元素的，而HashMap是尾部添加的（1.7头插，1.8尾插）

 

三、LinkedHashMap

• 核心
• LinkedHashMap是继承于HashMap，是基于HashMap和双向链表来实现的。
• HashMap无序；LinkedHashMap有序，可分为插入顺序和访问顺序两种。如果是访问顺序，那put和get操作已存在的Entry时，都会把Entry移动到双向链表的表尾(其实是先删除再插入)。
• LinkedHashMap存取数据，还是跟HashMap一样使用的Entry[]的方式，双向链表只是为了保证顺序。
• LinkedHashMap是线程不安全的。

 

LinkedHashMap是有序的，且默认为插入顺序

LinkedHashMap提供了多个构造方法，我们先看空参的构造方法。

public LinkedHashMap() {

// 调用HashMap的构造方法，其实就是初始化Entry[] table

super();

// 这里是指是否基于访问排序，默认为false

accessOrder = false;

}

首先使用super调用了父类HashMap的构造方法，其实就是根据初始容量、负载因子去初始化Entry[] table，详细的看上一篇HashMap解析。

然后把accessOrder设置为false，这就跟存储的顺序有关了，LinkedHashMap存储数据是有序的，而且分为两种：插入顺序和访问顺序。

这里accessOrder设置为false，表示不是访问顺序而是插入顺序存储的，这也是默认值，表示LinkedHashMap中存储的顺序是按照调用put方法插入的顺序进行排序的。

通过get方法，导致key为name1对应的Entry到表尾

 

 

数据结构（1.7继承Map.Entry<K,V>），比HashMap多了before, after;

static class Entry<K,V> extends HashMap.Node<K,V> {

        Entry<K,V> before, after;

        Entry(int hash, K key, V value, Node<K,V> next) {

            super(hash, key, value, next);

        }

    }

LinkedHashMap构造函数，主要就是调用HashMap构造函数初始化了一个Entry[] table，然后调用自身的init初始化了一个只有头结点的双向链表。

LinkedHashMap就是HashMap+双向链表，下面用图来表示逐步往LinkedHashMap中添加数据的过程，红色部分是双向链表，黑色部分是HashMap结构，header是一个Entry类型的双向链表表头，本身不存储数据。

 

Entry<K,V> e = new Entry<>(hash, key, value, old);

table[bucketIndex] = e;

// 把新创建的Entry，加入到双向链表中

e.addBefore(header);

 

private void addBefore(Entry<K,V> existingEntry) {

after = existingEntry;

before = existingEntry.before;

before.after = this;

after.before = this;

}

一直是一个环（新添加的连接header）

 

put（ 其实是先删除，再插入）

举个栗子：开始时，HashMap中有Entry1、Entry2、Entry3，并设置LinkedHashMap为访问顺序，则更新Entry1时，会先把Entry1从双向链表中删除，然后再把Entry1加入到双向链表的表尾，而Entry1在HashMap结构中的存储位置没有变化

 

get（ 其实是先删除，再插入）

首先通过key算出hash值，然后根据hash值算出在table中存储的index，然后遍历table[index]的单向链表去对比key，如果找到了就返回Entry。

后面调用了LinkedHashMap.Entry的recordAccess方法，上面分析过put过程中这个方法，其实就是在访问顺序的LinkedHashMap进行了get操作以后，重新排序，把get的Entry移动到双向链表的表尾。

 

在上一篇HashMap中就分析了remove过程，其实就是断开其他对象对自己的引用。比如被删除Entry是在单向链表的表头，则让它的next放到表头，这样它就没有被引用了；如果不是在表头，它是被别的Entry的next引用着，这时候就让上一个Entry的next指向它自己的next，这样，它也就没被引用了。

在HashMap.Entry中recordRemoval方法是空实现，但是LinkedHashMap.Entry对其进行了重写，如下：

void recordRemoval(HashMap<K,V> m) {

remove();

}

 

private void remove() {

before.after = after;

after.before = before;

}

易知，这是要把双向链表中的Entry删除，也就是要断开当前要被删除的Entry被其他对象通过after和before的方式引用

 

 

四、TreeMap

TreeMap 默认排序规则：按照key的字典顺序来排序（升序）

当然，也可以自定义排序规则：要实现Comparator接口。

Comparator<test> comparator = new Comparator<test>() {

                  @Override

                  public int compare(test o1, test o2) {

                        // 自定义规则返回-1 0 1

                        return 0;

                  }

            };

new TreeMap<>(comparator);

(01) TreeMap实现继承于AbstractMap，并且实现了NavigableMap接口。

(02) TreeMap的本质是R-B Tree(红黑树)，它包含几个重要的成员变量： root, size, comparator。

　　root 是红黑数的根节点。它是Entry类型，Entry是红黑数的节点，它包含了红黑数的6个基本组成成分：key(键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜色)。Entry节点根据key进行排序，Entry节点包含的内容为value。 

　　红黑数排序时，根据Entry中的key进行排序；Entry中的key比较大小是根据比较器comparator来进行判断的。

　　size是红黑数中节点的个数。

 

 

1.1 红黑树的节点颜色--红色

private static final boolean RED = false;

1.2 红黑树的节点颜色--黑色

private static final boolean BLACK = true;

1.3 “红黑树的节点”对应的类。

static final class Entry<K,V> implements Map.Entry<K,V> { ... }

Entry包含了6个部分内容：key(键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜色)

Entry节点根据key进行排序，Entry节点包含的内容为value。

 

2 相关操作

2.1 左旋

private void rotateLeft(Entry<K,V> p) { ... }

2.2 右旋

private void rotateRight(Entry<K,V> p) { ... }

2.3 插入操作

public V put(K key, V value) { ... }

2.4 插入修正操作

红黑树执行插入操作之后，要执行“插入修正操作”。

目的是：保红黑树在进行插入节点之后，仍然是一颗红黑树

private void fixAfterInsertion(Entry<K,V> x) { ... }

2.5 删除操作

private void deleteEntry(Entry<K,V> p) { ... }

2.6 删除修正操作

红黑树执行删除之后，要执行“删除修正操作”。

目的是保证：红黑树删除节点之后，仍然是一颗红黑树

private void fixAfterDeletion(Entry<K,V> x) { ... }