[改善Java代码]减少HashMap中元素的数量

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

 import java.util.HashMap;
 import java.util.Map; public class Client {
     public static void main(String[] args) {
         Map<String, String> map = new HashMap<String, String>();
         final Runtime rt = Runtime.getRuntime();
         // JVM终止前记录内存信息
         rt.addShutdownHook(new Thread() {
             @Override
             public void run() {
                 StringBuffer sb = new StringBuffer();
                 long heapMaxSize = rt.maxMemory() >> 20;
                 sb.append("最大可用内存：" + heapMaxSize + "M\n");
                 long total = rt.totalMemory() >> 20;
                 sb.append("对内存大小：" + total + "M\n");
                 long free = rt.freeMemory() >> 20;
                 sb.append("空闲内存：" + free + "M");
                 System.out.println(sb);
             }
         });
         // 放入40万键值对
         for (int i = 0; i < 40*10000; i++) {
             map.put("key" + i, "vlaue" + i);
         }
     }
 }

运行结果:

Exception in thread "main" 最大可用内存：247M
对内存大小：247M
空闲内存：8M
java.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中看看会怎么样,看代码:

 import java.util.ArrayList;
 import java.util.List; public class Client {
     public static void main(String[] args) {
         List<String> list = new ArrayList<String>();
         final Runtime rt = Runtime.getRuntime();
         // JVM终止前记录内存信息
         rt.addShutdownHook(new Thread() {
             @Override
             public void run() {
                 StringBuffer sb = new StringBuffer();
                 long heapMaxSize = rt.maxMemory() >> 20;
                 sb.append("最大可用内存：" + heapMaxSize + "M\n");
                 long total = rt.totalMemory() >> 20;
                 sb.append("对内存大小：" + total + "M\n");
                 long free = rt.freeMemory() >> 20;
                 sb.append("空闲内存：" + free + "M");
                 System.out.println(sb);
             }
         });
         // 放入40万同样字符串
         for (int i = 0; i < 502654; i++) {
             list.add("key" + i);
             list.add("vlaue" + i);
         }
     }
 }

运行输出:

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

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

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

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

     static class Entry<K,V> implements Map.Entry<K,V> {
         //键
         final K key;
         //值
         V value;
         //相同哈希码的下一个元素
         Entry<K,V> next;         final int hash;
         //key,value的getter和setter方法,以及重写的equals,hashCode,toString方法
     }

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的长度增长…..

 public class Client {
     public static void main(String[] args) {
         //Map的最后一次扩容
         int mapSize =16;
         for(int i=0;i<100;i++){
             mapSize = mapSize * 2;
             if(mapSize > 40*10000){
                 System.out.println(i);
                 System.out.println("map的最后一次扩容：" + (mapSize *3/4));
                 return;
             }
         }         int listSize = 10;
         for (int i = 1; i < 1000; i++) {
             listSize = (listSize * 3) / 2 + 1;
             if (listSize > 40 * 10000 * 2) {
                 System.out.println("list的最后一次扩容:"+listSize);
                 return;
             }
         }     } }