Map源码分析及浅谈

map实现

1：HashMap是允许key为nul的，在put元素时，首先根据key计算hash

     static final int hash(Object key) {

          int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); 

          //hash的目的是为了希望能够尽量均匀

            >>> : 无符号右移，忽略符号位，空位都以0补齐

             ^ : 位异或 第一个操作数的的第n位于第二个操作数的第n位相反，那么结果的第n为也为1，否则为0

}

2.HashMap 内部存储使用了一个 Node 数组(默认大小是16)，每个Node都是一个链表。每个链表存储相同索引的元素。之所以采       取这样的数据结构存储数据是为了防止冲突发生：Java中两个不同的对象可能有一样的hashCode,所以不同的键可能有一样          hashCode，从而导致冲突的产生。

Java 8开始，HashMap（ConcurrentHashMap以及LinkedHashMap）在处理频繁冲突时，为了提升性能将使用平衡树来代替链表，当同一hash桶中的元素数量超过特定的值（TREEIFY_THRESHOLD ）便会由链表切换到平衡树，这会将get()方法的性能从O(n)提高到O(logn)。

线程不安全

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

1. 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;
        if ((tab = table) == null || (n = tab.length) == 0) 
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)　　　　//如果该位置为null，说明没有哈希冲突，直接插入  --------------------（1）
            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) {
                    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;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

如果有两个线程A和B，都进行插入数据，刚好这两条不同的数据经过哈希计算后得到的哈希码是一样的，且该位置还没有其他的数据。所以这两个线程都会进入我在上面标记为1的代码中。假设一种情况，线程A通过if判断，该位置没有哈希冲突，进入了if语句，还没有进行数据插入，这时候CPU就把资源让给了线程B，线程A停在了if语句里面，线程B判断该位置没有哈希冲突（线程A的数据还没插入），也进入了if语句，线程B执行完后，轮到线程A执行，现在线程A直接在该位置插入而不用再判断。这时候，你会发现线程A把线程B插入的数据给覆盖了。发生了线程不安全情况。本来在HashMap中，发生哈希冲突是可以用链表法或者红黑树来解决的，但是在多线程中，可能就直接给覆盖了

2. resize而引起死循环（JDK1.8已经不会出现该问题）

这种情况发生在JDK1.7 中HashMap自动扩容时，当2个线程同时检测到元素个数超过 数组大小 × 负载因子。此时2个线程会在put()方法中调用了resize()，两个线程同时修改一个链表结构会产生一个循环链表（JDK1.7中，会出现resize前后元素顺序倒置的情况）。接下来再想通过get()获取某一个元素，就会出现死循环。

线程安全的Map

• Hashtable
• ConcurrentHashMap
• Synchronized Map

安全分析：

Hashtable （deprecate）

Hashtable 源码中是使用 synchronized 来保证线程安全的，比如下面的 get 方法和 put 方法：

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

所以当一个线程访问 HashTable 的同步方法时，其他线程如果也要访问同步方法，会被阻塞住。因此Hashtable效率很低，基本被废弃。

ConcurrentHashMap

ConcurrentHashMap沿用了与它同时期的HashMap版本的思想，底层依然由“数组”+链表+红黑树的方式思想，但是为了做到并发，又增加了很多辅助的类，例如TreeBin，Traverser等对象内部类。

且与hashtable不同的是：

ConcurrentHashMap没有对整个hash表进行锁定，而是采用了分离锁（segment）的方式进行局部锁定。具体体现在，它在代码中维护着一个segment数组。

TreeMap：

基于红黑二叉树的NavigableMap的实现，线程非安全，不允许null，key不可以重复，value允许重复，存入TreeMap的元素应当实现Comparable接口或者实现Comparator接口，会按照排序后的顺序迭代元素，两个相比较的key不得抛出classCastException。主要用于存入元素的时候对元素进行自动排序，迭代输出的时候就按排序顺序输出