ConcurrentHashMap线程安全，相对hashtable提高性能

//hashtable 是针对整个hash列表做一个锁定， //Collections.synchronizedMap :对所有方法加锁，故性能比价差 //ConcurrentHashMap是针对桶锁定，默认16个桶，故相对hashtable，性能很大的提高,锁分段技术  //建议使用ConcurrentHashMap； final Segment[] segments; static final class Segment extends ReentrantLock implements Serializable {     transient volatile HashEntry[] table;     transient int count;     transient int modCount;     transient int threshold;     final float loadFactor; } static final class HashEntry {     final int hash;     final K key;     volatile V value;     volatile HashEntry next;          //volatile 保证可见性，读取的时候不用加锁 } //put(),remove(),clear()等操作针对桶(segment)加锁， //get()不需要加锁 //size()有没加锁？ public int size() {     final Segment[] segments = this.segments;     int size;     boolean overflow; // true if size overflows 32 bits     long sum;         // sum of modCounts     long last = 0L;   // previous sum     int retries = -1; // first iteration isn't retry     try {         for (;;) {             if (retries++ == RETRIES_BEFORE_LOCK) {                 for (int j = 0; j < segments.length; ++j)                     ensureSegment(j).lock(); // force creation             }             sum = 0L;             size = 0;             overflow = false;             for (int j = 0; j < segments.length; ++j) {                 Segment seg = segmentAt(segments, j);                 if (seg != null) {                     sum += seg.modCount;                     int c = seg.count;                     if (c < 0 || (size += c) < 0)                         overflow = true;                 }             }             //尝试两次，如果modCount 一样，则返回size，             //如果不一样，锁住所有的桶，重新开始计算size             if (sum == last)                 break;             last = sum;         }     } finally {         if (retries > RETRIES_BEFORE_LOCK) {             for (int j = 0; j < segments.length; ++j)                 segmentAt(segments, j).unlock();         }     }     return overflow ? Integer.MAX_VALUE : size; }