transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

static class Entry<K,V> implements Map.Entry<K,V> {        final K key;        V value;        Entry<K,V> next;//存儲(chǔ)指向下一個(gè)Entry的引用，單鏈表結(jié)構(gòu)        int hash;//對(duì)key的hashcode值進(jìn)行hash運(yùn)算后得到的值，存儲(chǔ)在Entry，避免重復(fù)計(jì)算
        /**         * Creates new entry.         */        Entry(int h, K k, V v, Entry<K,V> n) {            value = v;            next = n;            key = k;            hash = h;        }

public V put(K key, V value) {        if (key == null)            return putForNullKey(value);        int hash = hash(key.hashCode());        int i = indexFor(hash, table.length);        for (Entry<K,V> e = table[i]; e != null; e = e.next) {            Object k;            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }
        modCount++;        addEntry(hash, key, value, i);        return null;    }

voidaddEntry(int hash, K key, V value, int bucketIndex) {  Entry<K,V> e = table[bucketIndex];      table[bucketIndex] = new Entry<K,V>(hash, key, value, e);      if (size++ >= threshold)          resize(2 * table.length);}

Entry( int h, K k, V v, Entry<K,V> n) {        value = v;        next = n;        key = k;        hash = h;}

//e是p的下一個(gè)節(jié)點(diǎn)if ((e = p.next) == null) {   //插入鏈表的尾部   p.next = newNode(hash, key, value, null);   //如果插入后鏈表長度大于8則轉(zhuǎn)化為紅黑樹   if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st       treeifyBin(tab, hash);   break;}

/** * Returns index for hash code h. */static int indexFor(int h, int length) {    return h & (length-1);}

threshold = (int)(capacity * loadFactor);void addEntry(int hash, K key, V value, int bucketIndex) {    if ((size >= threshold) && (null != table[bucketIndex])) {        resize(2 * table.length);//當(dāng)size超過臨界閾值threshold，并且即將發(fā)生哈希沖突時(shí)進(jìn)行擴(kuò)容        hash = (null != key) ? hash(key) : 0;        bucketIndex = indexFor(hash, table.length);    }
    createEntry(hash, key, value, bucketIndex);}

private static final int DEFAULT_CONCURRENCY_LEVEL = 16;private void writeObject(java.io.ObjectOutputStream s)        throws java.io.IOException {        // For serialization compatibility        // Emulate segment calculation from previous version of this class        int sshift = 0;        int ssize = 1;        while (ssize < DEFAULT_CONCURRENCY_LEVEL) {            ++sshift;            ssize <<= 1;        }        int segmentShift = 32 - sshift;        int segmentMask = ssize - 1;

int cap = 1;while (cap < c)    cap <<= 1

staticclass Segment<K,V> extends ReentrantLock implements Serializable {    private static final long serialVersionUID = 2249069246763182397L;    final float loadFactor;    Segment(float lf) { this.loadFactor = lf; }}

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<K,V> seg = segmentAt(segments, j);            if (seg != null) { sum += seg.modCount; int c = seg.count; if (c < 0 || (size += c) < 0)               overflow = true;            } }        if (sum == last) break;        last = sum; } }finally {    if (retries > RETRIES_BEFORE_LOCK) {        for (int j = 0; j < segments.length; ++j)            segmentAt(segments, j).unlock();    }}

// node數(shù)組最大容量：2^30=1073741824private static final int MAXIMUM_CAPACITY = 1 << 30;// 默認(rèn)初始值，必須是2的幕數(shù)private static final int DEFAULT_CAPACITY = 16//數(shù)組可能最大值，需要與toArray（）相關(guān)方法關(guān)聯(lián)static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//并發(fā)級(jí)別，遺留下來的，為兼容以前的版本private static final int DEFAULT_CONCURRENCY_LEVEL = 16;// 負(fù)載因子private static final float LOAD_FACTOR = 0.75f;// 鏈表轉(zhuǎn)紅黑樹閥值,> 8 鏈表轉(zhuǎn)換為紅黑樹static final int TREEIFY_THRESHOLD = 8;//樹轉(zhuǎn)鏈表閥值，小于等于6（tranfer時(shí)，lc、hc=0兩個(gè)計(jì)數(shù)器分別++記錄原bin、新binTreeNode數(shù)量，<=UNTREEIFY_THRESHOLD 則untreeify(lo)）static final int UNTREEIFY_THRESHOLD = 6;static final int MIN_TREEIFY_CAPACITY = 64;private static final int MIN_TRANSFER_STRIDE = 16;private static int RESIZE_STAMP_BITS = 16;// 2^15-1，help resize的最大線程數(shù)private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;// 32-16=16，sizeCtl中記錄size大小的偏移量private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;// forwarding nodes的hash值static final int MOVED     = -1;// 樹根節(jié)點(diǎn)的hash值static final int TREEBIN   = -2;// ReservationNode的hash值static final int RESERVED  = -3;// 可用處理器數(shù)量static final int NCPU = Runtime.getRuntime().availableProcessors();//存放node的數(shù)組transient volatile Node<K,V>[] table;/*控制標(biāo)識(shí)符，用來控制table的初始化和擴(kuò)容的操作，不同的值有不同的含義 *當(dāng)為負(fù)數(shù)時(shí)：-1代表正在初始化，-N代表有N-1個(gè)線程正在 進(jìn)行擴(kuò)容 *當(dāng)為0時(shí)：代表當(dāng)時(shí)的table還沒有被初始化 *當(dāng)為正數(shù)時(shí)：表示初始化或者下一次進(jìn)行擴(kuò)容的大小private transient volatile int sizeCtl;

static class Node<K,V> implements Map.Entry<K,V> {      final int hash;      final K key;      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;      }  }

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;      }
      Node<K,V> find(int h, Object k) {          return findTreeNode(h, k, null);      }
      /**       * Returns the TreeNode (or null if not found) for the given key       * starting at given root.       */      final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {          if (k != null) {              TreeNode<K,V> p = this;              do  {                  int ph, dir; K pk; TreeNode<K,V> q;                  TreeNode<K,V> pl = p.left, pr = p.right;                  if ((ph = p.hash) > h)                      p = pl;                  else if (ph < h)                      p = pr;                  else if ((pk = p.key) == k || (pk != null && k.equals(pk)))                      return p;                  else if (pl == null)                      p = pr;                  else if (pr == null)                      p = pl;                  else if ((kc != null ||                            (kc = comparableClassFor(k)) != null) &&                           (dir = compareComparables(kc, k, pk)) != 0)                      p = (dir < 0) ? pl : pr;                  else if ((q = pr.findTreeNode(h, k, kc)) != null)                      return q;                  else                      p = pl;              } while (p != null);          }          return null;      }  }