线程数组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）