Java中的Map

本文将讨论Java中的HashMap、LinkedHashMap、HashTable、ConcurrentHashMap。

1. HashMap

HashMap采用链接法解决碰撞。静态内部类Entry中有一个next引用指向下一个hash值相同的节点，所以table的每一个元素指向一个hash值相同的链表。

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; // 指向下一个hash值相同的节点
int hash;

/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}

...
}

由put方法可知，

1. HashMap支持null Key和null Value

2. HashMap线程不安全

@Override
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
int hash = hash(key);
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;
}

创建一个新的HashMapEntry，next指向当前的table[index]，即插入链表头。

void addEntry(K key, V value, int hash, int index) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}

createEntry(hash, key, value, bucketIndex);
}

void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}

2. LinkedHashMap

HashMap的迭代顺序是不确定的，而LinkedHashMap实现了按插入顺序或按访问顺序迭代。LinkedHashMap继承于HashMap，其中静态内部类Entry继承于HashMap.Entry，添加了before和after两个引用，在哈希表的基础上又构成了双向循环链表结构。若accessOrder == true，即按照访问顺序迭代，则需在访问某个节点后将其移到链表尾，具体分析Entry的recordAccess()方法。

/**
* 双向链表的头节点.
*/
private transient Entry<K,V> header;

/**
* 迭代顺序
* true  : 访问顺序
* false : 插入顺序
*/
private final boolean accessOrder;

public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}

/**
* LinkedHashMap entry.
*/
private static class Entry<K,V> extends HashMap.Entry<K,V> {
// These fields comprise the doubly linked list used for iteration.
Entry<K,V> before, after; // 当前节点的前节点和后节点

Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
super(hash, key, value, next);
}

/**
* Removes this entry from the linked list.
*/
private void remove() {
before.after = after;
after.before = before;
}

/**
* Inserts this entry before the specified existing entry in the list.
*/
private void addBefore(Entry<K,V> existingEntry) {
after  = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}

/**
* This method is invoked by the superclass whenever the value
* of a pre-existing entry is read by Map.get or modified by Map.set.
* If the enclosing Map is access-ordered, it moves the entry
* to the end of the list; otherwise, it does nothing.
*/
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
if (lm.accessOrder) {
// 若按照访问顺序迭代，则要将当前节点移到链表尾
lm.modCount++;
remove();
addBefore(lm.header);
}
}

void recordRemoval(HashMap<K,V> m) {
remove();
}
}

LinkedHashMap重写了HashMap的addEntry和createEntry方法，在创建节点的同时，要将新的节点插入链表尾。

void addEntry(int hash, K key, V value, int bucketIndex) {
super.addEntry(hash, key, value, bucketIndex);

// Remove eldest entry if instructed
Entry<K,V> eldest = header.after;
if (removeEldestEntry(eldest)) {
removeEntryForKey(eldest.key);
}
}

void createEntry(int hash, K key, V value, int bucketIndex) {
HashMap.Entry<K,V> old = table[bucketIndex];
Entry<K,V> e = new Entry<>(hash, key, value, old);
table[bucketIndex] = e;
// 新创建的节点插入链表尾
e.addBefore(header);
size++;
}

Android中的android.util.LruCache类使用了LinkedHashMap，并将accessOrder设为了true。这样就实现了LRU(Least Recent Used)，当cache命中时，将对应节点移到链表尾，当cache容量满了之后，可以删除链表头节点。

3. Hashtable

由put方法可见，Hashtable与HashMap实现方式类似，都用了链接法解决冲突。同时给方法添加syncrhonized关键字实现线程安全。

public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}

// Makes sure the key is not already in the hashtable.
Entry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}

modCount++;
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();

tab = table;
hash = hash(key);
index = (hash & 0x7FFFFFFF) % tab.length;
}

// Creates the new entry.
Entry<K,V> e = tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
return null;
}

HashTable容器使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法时，其他线程访问HashTable的同步方法时，可能会进入阻塞或轮询状态。如果线程1使用put进行添加元素，线程2不但不能使用put方法添加元素，并且不能使用get方法来获取元素，所以竞争越激烈效率越低。

如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。

synchronized实例方法是给对象上锁，如果是不同的对象，则各个对象之间没有限制关系。

synchronized类方法是给Class对象上锁

4. ConcurrentHashMap

java.util.concurrent.ConcurrentHashMap

ConcurrentHashMap使用了分段锁



ConcurrentHashMap 类中包含两个静态内部类 HashEntry 和 Segment。HashEntry 用来封装映射表的键 / 值对；Segment 用来充当锁的角色，每个 Segment 对象守护整个散列映射表的若干个桶。每个桶是由若干个 HashEntry 对象链接起来的链表。一个 ConcurrentHashMap 实例中包含由若干个 Segment 对象组成的数组。



Segment 类继承于 ReentrantLock 类，从而使得 Segment 对象能充当锁的角色。每个 Segment 对象用来守护其（成员对象 table 中）包含的若干个桶。

table 是一个由 HashEntry 对象组成的数组。table 数组的每一个数组成员就是散列映射表的一个桶。

ConcurrentHashMap 在默认并发级别会创建包含 16 个 Segment 对象的数组。每个 Segment 的成员对象 table 包含若干个散列表的桶。每个桶是由 HashEntry 链接起来的一个链表。如果键能均匀散列，每个 Segment 大约守护整个散列表中桶总数的 1/16。

在 ConcurrentHashMap 中，线程对映射表做读操作时，一般情况下不需要加锁就可以完成，对容器做结构性修改的操作才需要加锁。

ConcurrentHashMap不支持null Key。

参考资料

探索 ConcurrentHashMap 高并发性的实现机制