HashMap为什么线程不安全以及解决方法

众所周知，hashmap线程不安全而hashtable线程安全。最近在看并发编程就稍微研究了一下。先看一段JAVAAPI中对hashmap的介绍：

*注意，此实现不是同步的。如果多个线程同时访问此映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的不同步访问，如下所示：
Map m = Collections.synchronizedMap(new HashMap(…));*

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线程同时获得了同一个头节点并对其进行修改，这样A写入头节点之后B也写入头节点则会将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.
`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);  }  `以上是hashmap的增加容量的操作，如果同时A，B两个线程都要执行resize()操作，A线程已经进行在原基础的扩容，B线程也在原基础上扩容，这样就会造成线程不安全。下面写一个例子来验证一下

import java.util.HashMap;import java.util.Random;import java.util.concurrent.atomic.AtomicInteger;public class hashMap {    static void dos(){        HashMap<Long,String> ss=new HashMap<Long,String>();        final AtomicInteger in=new AtomicInteger(0);        ss.put(0L, "ssssssss");        for(int i=0;i<200;i++){            new Thread(new Runnable() {                         @Override                public void run() {                    // TODO Auto-generated method stub                    ss.put(System.nanoTime()+new Random().nextLong(),"ssssssssssss");                    String s=ss.get(0L);                    if(s==null){                        in.incrementAndGet();                    }                }            }).start();        }        System.out.println(in);    }    public static void main(String[] args) {        for(int i=0;i<10;i++){            dos();    }}}

结果并不都是0

但是如果将hashmap的初始大小设的大一些就不会出现这种情况。

下来研究一下如何使hashmap线程安全

http://flyfoxs.iteye.com/blog/2100120
//两种方式让hashmap线程安全

1.第一种办法api中已经有指出
如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的不同步访问，如下所示：
Map m = Collections.synchronizedMap(new HashMap(…));
即使用Collections.synchronizedMap()来返回一个新的map，但是这个返回的是不是hashmap，而是一个map的实现

第二种办法是改写hashmap。//暂时正在研究源码。。。