java自习室 day 5

集合

java集合框架
作者：Snailclimb

List

ArrayList

线程不同步，底层使用Object数组，指定插入删除操作时间复杂度为O(n-i)，实现了RandomAccess接口，支持快速随机访问。list列表最后预留一定容量空间。

LinkedList

线程不同步，底层使用双向循环链表。指定插入删除操作时间复杂度为O(1)，不支持快速随机访问。比起ArrayList，每一个元素需要消耗更多的空间，需要存放直接后继和直接前驱以及数据）。

Map

HashMap

线程不同步，底层采用数组+链表（红黑树）来实现。使用key来计算hashcode。采用拉链法解决哈希冲突。插入时，会插入到链表头部，查找时需要遍历链表，通过key对象的equals方法逐一比对查找。链表长度大于阈值（默认为8）时会转化成红黑树。
为了减少哈希碰撞的次数，应该将数据分配均匀。hashcode()采用取余操作来实现。存在这样一条性质：当除数是2的幂次时，取余操作等同于与除数减一的与操作（hash%length == hash&(length-1))。与操作可以提高运算效率。

ConcurrentHashMap

采用CAS和synchronized来保证并发安全。synchronized只锁定当前链表或红黑树的首节点，只要hash不冲突就不会产生并发。
ConcurrentHashMap底层具体实现
作者：上帝爱吃苹果
get操作：

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode()); //计算hash
    if ((tab = table) != null && (n = tab.length) > 0 &&
      (e = tabAt(tab, (n - 1) & h)) != null) {//读取首节点的Node元素
        if ((eh = e.hash) == h) { //如果该节点就是首节点就返回
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        //hash值为负值表示正在扩容，这个时候查的是ForwardingNode的find方法来定位到nextTable来
        //eh=-1，说明该节点是一个ForwardingNode，正在迁移，此时调用ForwardingNode的find方法去nextTable里找。
        //eh=-2，说明该节点是一个TreeBin，此时调用TreeBin的find方法遍历红黑树，由于红黑树有可能正在旋转变色，所以find里会有读写锁。
        //eh>=0，说明该节点下挂的是一个链表，直接遍历该链表即可。
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        while ((e = e.next) != null) {//既不是首节点也不是ForwardingNode，那就往下遍历
            if (e.hash == h &&
             ((ek = e.key) == key || (ek != null && key.equals(ek))))
                 return e.val;
        }
    }
    return null;
}

• 首先计算hash值，定位到table索引位置，如果首节点符合返回；
• 遇到扩容时，调用标志正在扩容节点ForwardingNode的find方法，查找该节点，匹配就返回；
• 以上都不符合时，往下遍历节点，匹配就返回，否则返回null。

volatile

volatile关键字保证了可见性和有序性。

• 对声明了volatile关键字的变量进行写操作时，JVM会对处理器发送一条指令，将这个变量所在缓存行的数据写回到系统内存。
• 在多处理器下，会使用缓存一致性协议。某个CPU写数据时如果发现操作的变量是共享变量，就会通知其他CPU该变量的当前缓存行无效，从主内存重新加载数据。
  
  通过volatile修饰Node节点的val元素与next指针，保证了多线程环境下线程A修改节点的val或新增节点对其他线程是可见的。

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    //可以看到这些都用了volatile修饰
    volatile V val;
    volatile Node<K,V> next;

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }

    public final K getKey() { return key; }
    public final V getValue() { return val; }
    public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
    public final String toString(){ return key + "=" + val; }
    public final V setValue(V value) {
        throw new UnsupportedOperationException();
    }

    public final boolean equals(Object o) {
        Object k, v, u; Map.Entry<?,?> e;
        return ((o instanceof Map.Entry) &&
          (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
          (v = e.getValue()) != null &&
          (k == key || k.equals(key)) &&
          (v == (u = val) || v.equals(u))); 
    }

    /**
    * Virtualized support for map.get(); overridden in subclasses.
    */
    Node<K,V> find(int h, Object k) {
        Node<K,V> e = this;
        if (k != null) {
            do {
                K ek;
                if (e.hash == h &&
                 ((ek = e.key) == k || (ek != null && k.equals(ek))))
                   return e;
            } while ((e = e.next) != null);
        }
        return null;
    }
}

volatile修饰Node数组是为了使得数组扩容时对其他线程可见。