java集合类_ConcurrentHashMap

ConcurrentHashMap在java1.8进行了重大的改进。
在JDK1.7版本中，ConcurrentHashMap的数据结构是由一个Segment数组和多个HashEntry组成，如下图所示：

Segment数组的意义就是将一个大的table分割成多个小的table来进行加锁，也就是上面的提到的锁分离技术，而每一个Segment元素存储的是HashEntry数组+链表，这个和HashMap的数据存储结构一样。

JDK1.8的实现
       JDK1.8的实现已经摒弃了Segment的概念，而是直接用Node数组+链表+红黑树的数据结构来实现，并发控制使用Synchronized和CAS来操作，虽然在JDK1.8中还能看到Segment的数据结构，但是已经简化了属性，只是为了兼容旧版本。ConcurrentHashMap是HashMap的升级版，HashMap是非线程安全的集合，ConcurrentHashMap则可以支持并发操作。 因为ConcurrentHashMap 和HashMap都是采用相同的数据结构，因此在分析ConcurrentHashMap 之前，最好先了解HashMap,这样更容易理解。

1、基础知识

1.1、静态常量

在深入学习JDK1.8 ConcurrentHashMap之前，先看一下其静态常量：

// node数组最大容量：2^30=1073741824
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认初始值，必须是2的幕数
static final int DEFAULT_CAPACITY = 16;
//数组可能最大值，需要与toArray（）相关方法关联
final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//并发级别，遗留下来的，为兼容以前的版本
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 负载因子
static final float LOAD_FACTOR = 0.75f;
// 链表转红黑树阀值,> 8 链表转换为红黑树
static final int TREEIFY_THRESHOLD = 8;
//树转链表阀值，小于等于6（tranfer时，lc、hc=0两个计数器分别++记录原bin、新binTreeNode数量，<=UNTREEIFY_THRESHOLD 则untreeify(lo)）
static final int UNTREEIFY_THRESHOLD = 6;
//存储方式由链表转成红黑树 table 容量的最小阈值
static final int MIN_TREEIFY_CAPACITY = 64;
//用于hash 表扩容后，搬移数据的步长（下面几个属性都是用于扩容或者控制sizeCtl 变量）
static final int MIN_TRANSFER_STRIDE = 16;
static int RESIZE_STAMP_BITS = 16;
// 2^15-1，help resize的最大线程数
static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
// 32-16=16，sizeCtl中记录size大小的偏移量
static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
// forwarding nodes的hash值
static final int MOVED     = -1; 
// 树根节点的hash值
static final int TREEBIN   = -2; 
// ReservationNode的hash值
static final int RESERVED  = -3; 
// 可用逻辑处理器数量,如果cup是2核4线程，返回4.
static final int NCPU = Runtime.getRuntime().availableProcessors();

1.2、Node

Node是ConcurrentHashMap存储结构的基本单元，继承于HashMap中的Entry，用于存储数据，源代码如下：

 static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;  //HashMap中该字段存放的是key.hashCode()；而ConcurrentHashMap存放的是spread(key.hashCode())
        final K key;   //key值
        volatile V val;  //value值
        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;
        }
}

static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
static final int spread(int h) {
        return (h ^ (h >>> 16)) & HASH_BITS;
}

1.3、TreeNode

TreeNode 用于构建红黑树节点，但是ConcurrentHashMap 中的TreeNode和HashMap中的TreeNode用途有点差别，HashMap中hash 表的部分位置上存储的是一颗树，具体存储的就是TreeNode型的树根节点，而ConcurrentHashMap 则不同，其hash 表是存储的被TreeBin 包装过的树，也就是存放的是TreeBin对象，而不是TreeNode对象，同时TreeBin 带有读写锁，当需要调整树时，为了保证线程的安全，必须上锁。
 

static final class TreeNode<K,V> extends Node<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
        TreeNode(int hash, K key, V val, Node<K,V> next,
                 TreeNode<K,V> parent) {
            super(hash, key, val, next);
            this.parent = parent;
        }
    }

TreeBin 对象

static final class TreeBin<K,V> extends Node<K,V> {
   TreeNode<K,V> root; // 树根
   volatile TreeNode<K,V> first; // 树的链式结构
   volatile Thread waiter; // 等待者
   volatile int lockState; // 锁状态
   // values for lockState
   static final int WRITER = 1; // set while holding write lock
   static final int WAITER = 2; // set when waiting for write lock
   static final int READER = 4; // increment value for setting read lock
}


ForwardingNode
static final class ForwardingNode<K,V> extends Node<K,V> {
  final Node<K,V>[] nextTable;
  ForwardingNode(Node<K,V>[] tab) {
      super(MOVED, null, null, null); // hash 值为MOVED 进行标识 
      this.nextTable = tab;
  }

ForwardingNode 用于在hash 表扩容过程中的过渡节点，当hash 表进行扩容进行数据转移的时候，其它线程如果还不断的往原hash 表中添加数据，这个肯定是不好的，因此就引入了ForwardingNode 节点，当对原hash 表进行数据转移时，如果hash 表中的位置还没有被占据，那么就存放ForwardingNode 节点，表明现在hash 表正在进行扩容转移数据阶段，这样，其它线程在操作的时候，遇到ForwardingNode 节点，就知道hash 现在的状态了，就可以协助参与hash 表的扩容过程。到这里，ConcurrentHashMap 中的重要的数据结构基本都了解了，一个是hash 表（table）,一个是链表节点Node,其实呢就是红黑树节点TreeNode。

1.4、Unsafe

       Unsafe类提供了一些绕开JVM的更底层功能，基于它的实现可以提高效率。但是，它是一把双刃剑：正如它的名字所预示的那样，它是不安全的，它所分配的内存需要手动free（不被GC回收）。java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作。

扫描二维码关注公众号，回复： 2811209 查看本文章

在ConcerrentHashMap中：

 // Unsafe mechanics
    private static final sun.misc.Unsafe U;
    private static final long SIZECTL;  //sizeCtl字段的偏移量
    private static final long TRANSFERINDEX;//transferIndex字段的偏移量
    private static final long BASECOUNT;//baseCount字段的偏移量
    private static final long CELLSBUSY;//cellsBusy字段的偏移量
    private static final long CELLVALUE；//CounterCell类中value字段的偏移量
    private static final long ABASE;//Node数组的头部偏移量
    private static final int ASHIFT;//保存的是

    static {
        try {
            U = sun.misc.Unsafe.getUnsafe();
            Class<?> k = ConcurrentHashMap.class;
            SIZECTL = U.objectFieldOffset
                (k.getDeclaredField("sizeCtl"));
            TRANSFERINDEX = U.objectFieldOffset
                (k.getDeclaredField("transferIndex"));
            BASECOUNT = U.objectFieldOffset
                (k.getDeclaredField("baseCount"));
            CELLSBUSY = U.objectFieldOffset
                (k.getDeclaredField("cellsBusy"));
            Class<?> ck = CounterCell.class;
            CELLVALUE = U.objectFieldOffset
                (ck.getDeclaredField("value"));
            Class<?> ak = Node[].class;
            ABASE = U.arrayBaseOffset(ak);
            int scale = U.arrayIndexScale(ak);
            if ((scale & (scale - 1)) != 0)//检测scale是不是2的幂。
                throw new Error("data type scale not a power of two");
            ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);//童年ASHIFT =√scale 
        } catch (Exception e) {
            throw new Error(e);
        }
    }
    /**
     * 获取tab数组中索引为i的值。
     */
    static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
    }
    /**
     * tab数组中,如果a[i]等于c，将a[i]设置成v并返回true，否则返回false
     */
    static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
    }
    /**
     * 取tab数组中索引为i的格子设置成v。
     */
    static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
        U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
    }

Unsafe这里不多说，但是我们要理解 "偏移量"、Unsafe.getObjectVolatile方法、Unsafe.compareAndSwapObject方法 和 Unsafe.putObjectVolatile方法的意思。
举个例子：

class Person {
    private String name="无";
}


public class UnsafeTest {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
//        Unsafe unsafe = Unsafe.getUnsafe();  //不允许外部使用，会抛异常。

        //通过反射获取unsafe对象
        Field theUnsafeInstance = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafeInstance.setAccessible(true);
        Unsafe unsafe = (Unsafe) theUnsafeInstance.get(Unsafe.class);

        //获取Person.name字段的偏移量
        long nameOffset = unsafe.objectFieldOffset
                (Person.class.getDeclaredField("name"));

        Person person = new Person();
        System.out.println((String)unsafe.getObjectVolatile(person,nameOffset));//无,获取name值。

        unsafe.compareAndSwapObject(person, nameOffset, "呜呜", "小黑");//false，”呜呜“不等于”无“，无法成功设置新值
        System.out.println((String)unsafe.getObjectVolatile(person,nameOffset));//无

        unsafe.compareAndSwapObject(person, nameOffset, "无", "小黑");//true ，成功设置新值
        System.out.println((String)unsafe.getObjectVolatile(person,nameOffset));//小黑

        unsafe.putObjectVolatile(person, nameOffset,"小强"); //这种方法强制设置新值，不关心旧值。
        System.out.println((String)unsafe.getObjectVolatile(person,nameOffset));//小强

    }
}

结果：

这个例子中，通过unsafe类完成了对person对象的操作。

unsafe类如何操作数组呢？

首先普及一下数组知识，数组是块连续的存储空间，如果数组中存放的是基本数据类型，是将数据直接保存在数组中；如果保存的是对象，其实只是保存的是对象的地址。

 public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {

        //通过反射获取unsafe对象
        Field theUnsafeInstance = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafeInstance.setAccessible(true);
        Unsafe unsafe = (Unsafe) theUnsafeInstance.get(Unsafe.class);

        long ABASE = unsafe.arrayBaseOffset(String[].class);//数组的头部偏移量
        int  scale = unsafe.arrayIndexScale(String[].class);//如果是基本数据类型的数组，返回数据类型长度，如long，返回8；否则，返回对象的地址长度，32位系统返回4,64位系统返回4或8.

        String[] stringArray = new String[10];
        String str = "哈哈";
        int index = 5;

        unsafe.putObjectVolatile(stringArray, ABASE + (index *scale), str);
        String StrNew = (String) unsafe.getObjectVolatile(stringArray, ABASE + (index *scale));

        System.out.println(StrNew);
        System.out.println(stringArray[index]);

    }

结果：

2、PUT方法

对于集合类的增删改查操作，其中最为重要的就是添加操作，理解了添加操作就掌握了这个集合。

public V put(K key, V value) {
    return putVal(key, value, false);
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)//tab为空时初始化tab。
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//tab[ (n - 1) & hash)]不存在时
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))//新创建的填node加到tab中，如果填加成功，跳出循环。
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)// 如果table位置上的节点状态时MOVE,则表明table正在进行扩容搬移数据的过程中
                tab = helpTransfer(tab, f); //协助扩容
            else {// hash 表该位置上有数据，可能是链表，也可能是一颗树
                V oldVal = null;
                synchronized (f) {/将table表该位置进行上锁，保证线程安全
                    if (tabAt(tab, i) == f) {// 上锁后，只有再该位置数据和上锁前一致才进行，否则需要重新循环
                        if (fh >= 0) {// hash 值>=0 表明这是一个链表结构
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {// 遍历链表
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) { // 将新数据添加到链表尾
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {// 该位置是红黑树，是TreeBin对象（注意是TreeBin，而不是TreeNode）
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                //添加了数据，需要进行检查
                 if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)  //if 成立，说明遍历的是链表结构，并且超过了阀值，需要将链表转换为树
                        treeifyBin(tab, i); //将table 索引i 的位置上的链表转换为红黑树
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
       // ConcurrentHashMap 容量增加1，检查是否需要扩容
        addCount(1L, binCount);
        return null;
    }

主要知识点:

1、计算key的hash 值。
HashMap中Node.hash存放的是key.hashCode()，为什么ConcurrentHashMap 中Node.hash存放 spread(key.hashCode())？因为ConcurrentHashMap 中Node.hash还被用来作标识，
当Node.hash=-1时表示这是一个forwardNode节点；
当Node.hash=-2时表示这时一个TreeBin节点；
当Node.hash=-3时表示短暂保留节点；
当Node.hash>=0时表示这时一个普通node节点。

因为key.hashCode()有可能返回负数（-1、-2），因此ConcurrentHashMap中Node.hash就不能在直接使用key.hashCode()，所以使用spread方法进行转换，spread方法的返回值一定大于等于0。

 static final int MOVED     = -1; // hash for forwarding nodes
 static final int TREEBIN   = -2; // hash for roots of trees
 static final int RESERVED  = -3; // hash for transient reservations
 static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash

static final int spread(int h) {
    return (h ^ (h >>> 16)) & HASH_BITS;
}

2、initTable方法

如果table没有被初始化，则执行table的初始化过程，使用initTable方法对table进行始化。

/*控制标识符，用来控制table的初始化和扩容的操作，不同的值有不同的含义：
 *当为负数时：-1代表正在初始化，-N代表有N-1个线程正在 进行扩容
 *当为0时：代表当时的table还没有被初始化
 *当为正数时：表示初始化或者下一次进行扩容的大小
 */
private transient volatile int sizeCtl; 


public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        this.sizeCtl = cap;
    }

private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            if ((sc = sizeCtl) < 0)//sizeCtl为-1代表别的线程正在初始化，-N代表有N-1个线程正在 进行扩容
                Thread.yield(); // 线程让步，其实就是等待别的线程操作完成。
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//sizeCtl为0表于table还没有被初始化；设置成-1,开始初始化
                try {
                    if ((tab = table) == null || tab.length == 0) {
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;//获取table初始化大小
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        sc = n - (n >>> 2);//设置下一次进行扩容的大小。
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }