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; }