线程数组HashMap为什么是线程不安全的?

废话就不多说了,开始。。。

    一直以来只是知道HashMap是线程不安全的,但是到底HashMap为什么线程不安全,多线程并发的时候在什么情况下可能出现问题?

    HashMap底层是一个Entry数组,当产生hash冲突的时候,hashmap是采取链表的方法来解决的,在对应的数组位置寄存链表的头结点。对链表而言,新加入的节点会从头结点加入。

    javadoc中关于hashmap的一段描述如下:

    此实现不是同步的。如果多个线程同时访问一个哈希映射,而其中至少一个线程从结构上修改了该映射,则它必须 坚持外部同步。(结构上的修改是指添加或删除一个或多个映射关系的任何操纵;仅转变与实例已经包含的键关联的值不是结构上的修改。)这一般通过对自然封装该映射的对象停止同步操纵来完成。如果不存在这样的对象,则应当应用 Collections.synchronizedMap 方法来“包装”该映射。最好在创立时完成这一操纵,以避免对映射停止不测的非同步访问,如下所示:

Map m = Collections.synchronizedMap(new HashMap(...));

    

    1、

void addEntry(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);
    }

    在hashmap做put操纵的时候会调用到以上的方法。当初假如A线程和B线程同时对同一个数组位置调用addEntry,两个线程会同时得到当初的头结点,然后A写入新的头结点以后,B也写入新的头结点,那B的写入操纵就会覆盖A的写入操纵造成A的写入操纵丧失

    2、

    每日一道理
能够破碎的人,必定真正活过。林黛玉的破碎,在于她有刻骨铭心的爱情;三毛的破碎,源于她历经沧桑后一刹那的明彻与超脱;凡高的破碎,是太阳用黄金的刀子让他在光明中不断剧痛,贝多芬的破碎,则是灵性至极的黑白键撞击生命的悲壮乐章。如果说那些平凡者的破碎泄漏的是人性最纯最美的光点,那么这些优秀的灵魂的破碎则如银色的梨花开满了我们头顶的天空。
final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

    删除键值对的代码如上:

    当多个线程同时操纵同一个数组位置的时候,也都会先取得当初状态下该位置存储的头结点,然后各自去停止盘算操纵,以后再把结果写会到该数组位置去,其实写回的时候可能其他的线程已经就把这个位置给修改过了,就会覆盖其他线程的修改

    3、addEntry中当加入新的键值对后键值对总数量超过门限值的时候会调用一个resize操纵,代码如下:

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);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

    这个操纵会新生成一个新的容量的数组,然后对原数组的所有键值对重新停止盘算和写入新的数组,以后指向新生成的数组。

    当多个线程同时检测到总数量超过门限值的时候就会同时调用resize操纵,各自生成新的数组并rehash后赋给该map底层的数组table,结果最终只有最后一个线程生成的新数组被赋给table变量,其他线程的均会丧失。而且当某些线程已经完成赋值而其他线程刚开始的时候,就会用已经被赋值的table作为原始数组,这样也会有问题。

    

    

    

    

文章结束给大家分享下程序员的一些笑话语录: 问答
Q:你是怎么区分一个内向的程序员和一个外向的程序员的? A:外向的程序员会看着你的鞋和你说话时。
Q:为什么程序员不能区分万圣节和圣诞节? A:这是因为 Oct 31 == Dec 25!(八进制的 31==十进制的 25)

原文地址:https://www.cnblogs.com/xinyuyuanm/p/3093348.html