Java性能优化——HashCode的使用

背景

告警子系统监控4万个大网元所有端口的某些指标数据，根据阈值配置判断是否产生告警。采集——数据处理子系统每5分钟会主动采集24万次数据，发送24万条消息给告警子系统，这24万条消息涉及100万实体的数十个指标数据。告警子系统采用多节点部署方式分担压力，每个节点处理不同网元类型，不同实体，不同指标的数据。海量数据的过滤，必然会大量使用集合逻辑运算，使用不当，则会造成性能瓶颈。

例子

存在告警节点监控的实体动态变化，所以每个告警节点需要动态维护自己的监控列表，所以代码中会用到Collection.removeAll求差集的计算，计算出新增的实体，然后进一步计算出这些新增实体的历史平均值，方差等数据。

package com.coshaho.hash;

import java.util.ArrayList;
import java.util.List;

public class HashObject {
    
    public static void main(String[] args)
    {
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        
        // 2000长度的List求差集
        for(int i = 0; i < 2000; i++)
        {
            list1.add("" + i);
            list2.add("" + (i + 1));
        }
        long startTime = System.currentTimeMillis();
        list1.removeAll(list2);
        long endTime = System.currentTimeMillis();
        System.out.println("2000 list remove all cost: " + (endTime - startTime) + "ms.");
        
        // 10000长度的List求差集
        list1.clear();
        list2.clear();
        for(int i = 0; i < 10000; i++)
        {
            list1.add("" + i);
            list2.add("" + (i + 1));
        }
        startTime = System.currentTimeMillis();
        list1.removeAll(list2);
        endTime = System.currentTimeMillis();
        System.out.println("10000 list remove all cost: " + (endTime - startTime) + "ms.");
        
        // 50000长度的List求差集
        list1.clear();
        list2.clear();
        for(int i = 0; i < 50000; i++)
        {
            list1.add("" + i);
            list2.add("" + (i + 1));
        }
        startTime = System.currentTimeMillis();
        list1.removeAll(list2);
        endTime = System.currentTimeMillis();
        System.out.println("50000 list remove all cost: " + (endTime - startTime) + "ms.");
    }
}

上述代码我们分别对长度为2000,10000,50000的List进行了求差集的运算，耗时如下：

2000 list remove all cost: 46ms.
10000 list remove all cost: 1296ms.
50000 list remove all cost: 31028ms.

可以看到，数据量每增加5倍，ArrayList的求差集运算时间消耗增加30倍。当我们进行数十万元素的求差集运算时，时间消耗是我们不可承受的。

Equals

实体过滤中，为了找到我们关心的实体数据，我们必然会采用Collection.contains过滤实体ID，这里面会使用到字符串equals方法判断两个ID是否相等。对于我们来说，两个字符串相等的含义就是两个字符串长度一致，对应位置的字符编码相等。如果大量字符串两两比较都采用上述算法，那将会进行海量的运算，消耗大量性能。这个时候，HashCode的作用就显得尤其重要。

HashCode

HashCode是int类型。两个对象如果相等（equals为true），则HashCode必然相等；反之，HashCode不等的两个对象，equals必然为false。最优秀的Hash算法，不相等的对象HashCode都不相同，所有equals比较都只调用HashCode的恒等比较，那么计算量就大大减小了。实际上，任何一个Hash算法都不能达到上述要求（HashCode为int类型，说明HashCode取值范围有限，对象超过int取值范围个数，就必然出现不相等对象对应同一个HashCode值）。不相等的对象对应相同的HashCode称之为Hash冲突。

但是，好的Hash算法确出现Hash冲突的概率极低。比如0.01%的Hash冲突概率，这样就意味着，我们平均进行10000次不相等对象的equals比较，只会出现一次Hash冲突，也就意味着只需要调用一次equals主逻辑。我们在设计equals方法时，先比较两个对象HashCode是否相等，不相等则返回false，相等才进行equals主逻辑比较。

原始的HashCode方法是由虚拟机本地实现的，可能采用的对象地址进行运算。String复写了HashCode方法，代码如下：

    // Object
    public native int hashCode();

    // String
    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

HashMap
HashMap是一个利用Key的HashCode进行散列存储的容器。它采用数组->链表->红黑树存储数据。结构如下图：

最简单的设想，计算一个Key在数组中的位置时，采用HashCode%数组长度求余计算则可（实际上JDK采用了更好的散列算法）。可以想象，相同的散列算法下，数组长度越长，Hash冲突概率越小，但是使用的空间越大。

JDK默认采用0.75为元素容量与数组长度的比例。默认初始化数组长度为16（采用2的n次方是考虑HashMap的扩容性能），当元素个数增加到16*0.75=12个时，数组长度会自动增加一倍，元素位置会被重新计算。在数据量巨大的情况下，我们初始化HashMap时应该考虑初始化足够的数组长度，特别是性能优先的情况下，我们还可以适当减小元素容量与数组长度的比例。HashMap部分源码：

    /**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and load factor.
     *
     * @param  initialCapacity the initial capacity
     * @param  loadFactor      the load factor
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        init();
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and the default load factor (0.75).
     *
     * @param  initialCapacity the initial capacity.
     * @throws IllegalArgumentException if the initial capacity is negative.
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

大数据集合运算性能考虑
通过上述分析，我们知道在性能优先的场景下，大数据集合运算一定要使用Hash集合（HashMap，HashSet，HashTable）存储数据。文章开头的集合求余运算，我们修改为使用HashSet.removeAll，代码如下：

package com.coshaho.hash;

import java.util.Collection;
import java.util.HashSet;

public class HashObject {
    
    public static void main(String[] args)
    {
        Collection<String> list1 = new HashSet<String>();
        Collection<String> list2 = new HashSet<String>();
        
        // 2000长度的List求差集
        for(int i = 0; i < 2000; i++)
        {
            list1.add("" + i);
            list2.add("" + (i + 1));
        }
        long startTime = System.currentTimeMillis();
        list1.removeAll(list2);
        long endTime = System.currentTimeMillis();
        System.out.println("2000 list remove all cost: " + (endTime - startTime) + "ms.");
        
        // 10000长度的List求差集
        list1.clear();
        list2.clear();
        for(int i = 0; i < 10000; i++)
        {
            list1.add("" + i);
            list2.add("" + (i + 1));
        }
        startTime = System.currentTimeMillis();
        list1.removeAll(list2);
        endTime = System.currentTimeMillis();
        System.out.println("10000 list remove all cost: " + (endTime - startTime) + "ms.");
        
        // 50000长度的List求差集
        list1.clear();
        list2.clear();
        for(int i = 0; i < 50000; i++)
        {
            list1.add("" + i);
            list2.add("" + (i + 1));
        }
        startTime = System.currentTimeMillis();
        list1.removeAll(list2);
        endTime = System.currentTimeMillis();
        System.out.println("50000 list remove all cost: " + (endTime - startTime) + "ms.");
    }
}

运行效果如下：

2000 list remove all cost: 31ms.
10000 list remove all cost: 0ms.
50000 list remove all cost: 16ms.