在系统开发中我们经常会使用HashMap作为数据集容器,或者是用缓冲池来处理,一般很稳定,但偶尔也会出现内存溢出的问题(OutOfMemory错误),而且这经常是与HashMap有关的.而且这经常是与HashMap有关的.比如我们使用缓冲池操作数据时,大批量的增删改产操作就可能会让内存溢出,下面建立一段模拟程序,重现该问题,看代码:

1 import java.util.HashMap; 2 import java.util.Map; 3  4 public class Client { 5     public static void main(String[] args) { 6         Map
     
       map = new HashMap
      
       (); 7         final Runtime rt = Runtime.getRuntime(); 8         // JVM终止前记录内存信息 9         rt.addShutdownHook(new Thread() {10             @Override11             public void run() {12                 StringBuffer sb = new StringBuffer();13                 long heapMaxSize = rt.maxMemory() >> 20;14                 sb.append("最大可用内存：" + heapMaxSize + "M\n");15                 long total = rt.totalMemory() >> 20;16                 sb.append("对内存大小：" + total + "M\n");17                 long free = rt.freeMemory() >> 20;18                 sb.append("空闲内存：" + free + "M");19                 System.out.println(sb);20             }21         });22         // 放入40万键值对23         for (int i = 0; i < 40*10000; i++) {24             map.put("key" + i, "vlaue" + i);25         }26     }27 }
      
     

 运行结果:

Exception in thread "main" 最大可用内存：247M对内存大小：247M空闲内存：8Mjava.lang.OutOfMemoryError: Java heap space    at java.util.HashMap.resize(Unknown Source)    at java.util.HashMap.addEntry(Unknown Source)    at java.util.HashMap.put(Unknown Source)    at cn.summerchill.test.Client.main(Client.java:26)

内存溢出了....可能认为在运行时增加"-Xmx"参数设置内存大小就可以了,这确实可以,不过浮于表面,没有真正的从溢出的最根本原因上来解决问题.

难道的是String字符串太多了?字符串对象对象加起来撑死最多10MB,而且这里还空闲了7MB内存,不应该报内存溢出.....

或者是put方法有缺陷,产生了内存泄漏?不可能...这里还有7MB的内存可用,应该要用尽了才会出现内存泄漏.....

用ArrayList做一个对比,把相同数据插入到ArrayList中看看会怎么样,看代码:

1 import java.util.ArrayList; 2 import java.util.List; 3  4 public class Client { 5     public static void main(String[] args) { 6         List
     
       list = new ArrayList
      
       (); 7         final Runtime rt = Runtime.getRuntime(); 8         // JVM终止前记录内存信息 9         rt.addShutdownHook(new Thread() {10             @Override11             public void run() {12                 StringBuffer sb = new StringBuffer();13                 long heapMaxSize = rt.maxMemory() >> 20;14                 sb.append("最大可用内存：" + heapMaxSize + "M\n");15                 long total = rt.totalMemory() >> 20;16                 sb.append("对内存大小：" + total + "M\n");17                 long free = rt.freeMemory() >> 20;18                 sb.append("空闲内存：" + free + "M");19                 System.out.println(sb);20             }21         });22         // 放入40万同样字符串23         for (int i = 0; i < 502654; i++) {24             list.add("key" + i);25             list.add("vlaue" + i);26         }27     }28 }
      
     

 运行输出:

最大可用内存：247M对内存大小：95M空闲内存：27M

ArrayList运行很正常,没有出现内存溢出的情况,两个容器,容纳的元素相同,数量相同,ArrayList没有溢出,但HashMap却溢出了,很明显,这与HashMap内部的处理机制有很大的关系.

HashMap在底层也是以数组方式保存元素的,其中每一个键值对就是一个元素 ,也就是说HashMap把键值对封装成了一个Entry对象,然后再把Entry放到了数组中,我们简单看一下Entry类:

java.util.HashMap.Entry<K, V>

1     static class Entry
     
       implements Map.Entry
      
        { 2         //键 3         final K key; 4         //值 5         V value; 6         //相同哈希码的下一个元素 7         Entry
       
         next; 8          9         final int hash;10         //key,value的getter和setter方法,以及重写的equals,hashCode,toString方法11     }
       
      
     

 

HashMap底层的数组变量名叫table,它是Entry类型的数组,保存的是一个个的键值对(在我们的例子中Entry是由两个String类型组成的).对我们的例子来说,HashMap比ArrayList多了一次封装,把String类型的键值对转换成Entry对象后再放入数组,这就多了40万个对象,这应该是问题产生的一个原因.

我们知道HashMap的长度也是可以动态增加的,它的扩容机制与ArrayList稍有不同,其代码如下:

if (size++ >= threshold)

　　resize(2 * table.length);

 在插入键值对时,会做长度校验,如果大于或等于阀值(threshold变量),则数组长度增大一倍,不过,默认的阀值是多大呢?默认是当前长度与加载因子的乘积.

threshold = (int) (newCapacity * loadFactory);

默认的加载因子(loadFactor变量)是0.75,也就是说只要HashMap的size大于数组长度的0.75倍时,就开始扩容,经过计算得知(怎么计算,查找2的N次方大于40万的最小值即为数组的最大长度,再乘以0.75就是最后一次扩容点,计算的结果是19),

在Map的size为393216时,符合了扩容条件,于是393216个元素准备开始大搬家,那就要首先申请一个长度为1048576(当前长度的两倍,2的19次方再乘以2,即2的20次方)的数组,但问题是此时剩余的内存只有7Mb了.不足以支撑此时的运算.于是就报内存溢出了.这是第二个原因,也是最根本的原因.

这就解释了为什么还剩余7MB的时候就报内存溢出了.

再考虑下ArrayList的扩容策略,它是在小于数组长度的时候才会扩容1.5倍,经过计算得知,ArrayList的size在超过80万后(一次加两个元素,40万的两倍),最近的一次扩容会在size为1005308时,也就是说,如果程序设置了增加元素的上限为502655,同样会报内存溢出,因为他也要申请一个1507963长度的数组.如果没有这么大的地方,就报错了.

综合来说,HashMap比ArrayList多了一个层Entry的底层对象封装,多占用了内存,并且它的扩容策略是2倍长度的递增,同时还会依据阀值判断规则进行判断,因此相对于ArrayList来说,它就会先出现内存溢出.

 

尽量让HashMap中的元素少量并简单.

 

//============================================

模拟List和Map的长度增长.....

1 public class Client { 2     public static void main(String[] args) { 3         //Map的最后一次扩容 4         int mapSize =16; 5         for(int i=0;i<100;i++){ 6             mapSize = mapSize * 2; 7             if(mapSize > 40*10000){ 8                 System.out.println(i); 9                 System.out.println("map的最后一次扩容：" + (mapSize *3/4));10                 return;11             }12         }13         14         int listSize = 10;15         for (int i = 1; i < 1000; i++) {16             listSize = (listSize * 3) / 2 + 1;17             if (listSize > 40 * 10000 * 2) {18                 System.out.println("list的最后一次扩容:"+listSize);19                 return;20             }21         }22 23     }24 25 }