HashMap 与 ConcurrentHashMap

来源：互联网发布：网络言论自由权的内涵编辑：程序博客网时间：2024/05/17 03:21

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

0 0