都说concurrentHashmap很重要，很好用，今天总结一下，做个笔记。
先捋一下concurrentHashMap的属性
/** * 这个表的默认初始容量， * 在构造函数中没有指定的时候使用。 */
static final int DEFAULT_INITIAL_CAPACITY = 16;
/** * 这个表的默认加载因子，不用时使用 * 否则在构造函数中指定。 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/** * 这个表的默认并发级别，在不使用时使用 * 在构造函数中指定的 */
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/** * 最大容量，如果更高的值隐式使用 * 由具有参数的构造函数指定。 必须 * 是两个<= 1 << 30的幂以确保条目是可索引的 * 使用整数。 */
static final int MAXIMUM_CAPACITY = 1 << 30;
/** * 每个细分表格的最小容量。 必须是 * 两个，至少两个，以避免立即调整下次使用 */
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
/** * 允许的最大段数; 用来绑定 * 构造函数参数。。 */
static final int MAX_SEGMENTS = 1 << 16; // slightly conservative
/** * 包含大小和包含值的未同步重试次数 * 在诉诸锁定之前的方法。 这是用来避免 * 如果表格经历了不断的修改，那么无限制的重试 * 这将无法获得准确的结果。 */
static final int RETRIES_BEFORE_LOCK = 2;一、先看一下concurrentHashMap的数据结构
看下面，重点是那个Segment[] segments 数组
final int segmentMask;
/** * Shift value for indexing within segments. */
final int segmentShift;
/** * The segments, each of which is a specialized hash table. */
final Segment<K,V>[] segments;
transient Set<K> keySet;
transient Set<Map.Entry<K,V>> entrySet;
transient Collection<V> values;Segment 的结构，有个HashEntry 数组，并且继承了ReentrantLock ，到这里相信你已经明白了，每个segment都是一个锁，因此concurrentHashMap 的分段锁所得就是这个segment。
static final class Segment<K,V> extends ReentrantLock implements Serializable {
static final int MAX_SCAN_RETRIES =
Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
/** * The per-segment table. Elements are accessed via * entryAt/setEntryAt providing volatile semantics. */
transient volatile HashEntry<K,V>[] table;
/** * The number of elements. Accessed only either within locks * or among other volatile reads that maintain visibility. */
transient int count;
}HashEntry 结构有next的引用 是个链表结构
static final class HashEntry<K,V> {
final int hash;
final K key;
volatile V value;
volatile HashEntry<K,V> next;
HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
列出上面源码，就清楚可以看出concurrenthashMap 的数据结构了。 
图片画的有点糙，能看出道理就可以了。
concurrenthashMap是一个segment的数组，segment包含一个hashEntry的数组，hashentry是一个链表。
二、来一起走一遍源码
1、初始化
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
//判断加载因子、初始化容量、并发级别参数是否合法
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
//并发级别超过最大值，就设置为最大值
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// Find power-of-two sizes best matching arguments
//偏移量，定位的时候用
int sshift = 0;
//segment的个数，只能是2的幂次方
int ssize = 1;
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;
//初始化大小不能大于最大值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//下面是计算容量--------------------------
//平均一个segment有所少容量
int c = initialCapacity / ssize;
//必须是2的幂次方
if (c * ssize < initialCapacity)
++c;
//真正的计算容量，2的幂次方
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// create segments and segments[0]
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
2、get方法，没有加锁，老的版本还在查到是null的时候，会在加锁的情况下载查一遍。
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
3、put方法，首先是定位到那个segment，然后调用segment的put方法
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
int hash = hash(key);
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);
return s.put(key, hash, value, false);
}这个就是segment的put方法，分段锁就是在这里。put先判断key是否存在，存在覆盖，不存在，放在链表投。
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
if (e != null) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next;
}
else {
if (node != null)
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
else
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}
4、remove方法的套路和put是一样的，先定位，然后调用segment的remove。
public V remove(Object key) {
int hash = hash(key);
Segment<K,V> s = segmentForHash(hash);
return s == null ? null : s.remove(key, hash, null);
}这里是segment的remove
final V remove(Object key, int hash, Object value) {
if (!tryLock())
scanAndLock(key, hash);
V oldValue = null;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> e = entryAt(tab, index);
HashEntry<K,V> pred = null;
while (e != null) {
K k;
HashEntry<K,V> next = e.next;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
V v = e.value;
if (value == null || value == v || value.equals(v)) {
if (pred == null)
setEntryAt(tab, index, next);
else
pred.setNext(next);
++modCount;
--count;
oldValue = v;
}
break;
}
pred = e;
e = next;
}
} finally {
unlock();
}
return oldValue;
}