您的位置:首页 > 其它

HashMap 与 ConcurrentHashMap

2015-06-06 13:28 232 查看
1. HashMap

1) 并发问题

HashMap的并发问题源于多线程访问HashMap时, 如果存在修改Map的结构的操作(增删, 不包括修改), 则有可能会发生并发问题, 表现就是get()操作会进入无限循环

public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);

return null == entry ? null : entry.getValue();
}


final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}

int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}


究其原因, 是因为 getEntry 先获取了 table 中的链表, 而链表是一个循环链表, 所以进入了无限循环, 在正常情况下, 链表并不会出现循环的情况

出现这种情况是在多线程进行put的时候, 因为put会触发resize(rehash)操作, 当多个rehash同时发生时, 链表就有可能变得错乱, 变成一个循环链表

void addEntry(int hash, K key, V value, int bucketIndex) {
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 resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}

Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity)); // transfer 方法对所有Entry进行了rehash
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}


多线程resize的时候会同时创建多个newTable, 然后同时rehash, 造成链表错乱

另外rehash对于hashmap的性能代价也是相当大的, 所以选择一个合适的table长度也是很重要的

2) iterator 与 fail-fast

 遍历的两种方法

for (int i = 0; i < collection.size(); i++) {
T t = collection.get(i)
// ...
}

for (T t : collection) {
// ...
}


 

为什么使用iterator, 是因为有的数据结构 get(i) 的效率是O(n), 而非O(1), 例如 LinkedList, 那么整个循环的效率则会变为 O(n2)

iterator内部使用fail-fast机制来提醒并发问题的发生, 例如在遍历的时候同时修改map, 则会抛出ConcurrentModificationException异常

for (Entry<K, V> t : map) {
map.remove(t.key);
// Exception throw
}


 

之所以抛出异常是因为在遍历的时候同时修改map, 会导致一些意想不到的情况发生

1) remove 操作. 

假如在遍历的时候进行remove , 则有可能拿到的当前元素变为空, 导致遍历无法往下进行, 而直接跳到hashMap table的下一个槽位, 丢失整个槽位的链表数据

final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}

int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) { // 例如这里的 e.next 在遍历的时候被删除, 则会导致这个槽位的元素全被跳过
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}


 

 


2) put 操作

put操作的resize会导致table链表重新分配, 遍历则会变得混乱, 不再赘述

 

2. ConcurrentHashMap

ConcurrentHashMap是HashMap的线程安全实现, 不同于HashTable, 他并不是用对整个HashMap使用synchronized来保证同步, 而是对map进行分段, 在插入时只使用重入锁锁定特定的段

这样根据段位的数量则可以达到不同的并发数量, 所以在使用他时可以根据我们的并发线程来定制这个段的数量.

1) segment的数量是ssize = 1 << concurrencyLevel, 默认 DEFAULT_CONCURRENCY_LEVEL = 16

2) 每个segment的长度是 initialCapacity / ssize, 最小值为 MIN_SEGMENT_TABLE_CAPACITY = 2

同样, 他的Iterator也不同于传统的HashIterator, 他并不会抛出ConcurrentModificationException, 这是因为他的遍历器的next()方法, 每次都是返回一个new的WriteThroughEntry, 这个东西保证了你在获取到Entry以后即使Map遭到修改, 也不会影响你当前遍历的结果. 但是, 如果你对WriteThroughEntry进行setValue操作, 还是可以影响到原来的map的, 代码如下

final class EntryIterator
extends HashIterator
implements Iterator<Entry<K,V>>
{
public Map.Entry<K,V> next() {
HashEntry<K,V> e = super.nextEntry();
return new WriteThroughEntry(e.key, e.value);
}
}

/**
* Custom Entry class used by EntryIterator.next(), that relays
* setValue changes to the underlying map.
*/
final class WriteThroughEntry
extends AbstractMap.SimpleEntry<K,V>
{
WriteThroughEntry(K k, V v) {
super(k,v);
}

/**
* Set our entry's value and write through to the map. The
* value to return is somewhat arbitrary here. Since a
* WriteThroughEntry does not necessarily track asynchronous
* changes, the most recent "previous" value could be
* different from what we return (or could even have been
* removed in which case the put will re-establish). We do not
* and cannot guarantee more.
*/
public V setValue(V value) {
if (value == null) throw new NullPointerException();
V v = super.setValue(value);
ConcurrentHashMap.this.put(getKey(), value); // 将改变写入到原来的map中
return v;
}
}


内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: