面试：如果让你来做HashMap扩容，如何实现在不影响读写的情况下扩容？

笔者就遇到这样一个面试官，当时并不知道FastHashMap。我当时的回答是新建一个数据，保存原来HashMap里面的数据。被面试官追问到链表和红黑树数据怎么办？我就知道完了。当时也没有想到克隆！

FastHashMap

		<dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.4</version>
        </dependency>

一种定制实现，java.util.HashMap旨在在多线程环境中运行，在该环境中，大多数方法调用是只读的，而不是结构更改。在“快速”模式下运行时，读取调用不同步，而写入调用执行以下步骤：

• 克隆现有集合
• 在克隆集合上执行修改
• 将现有集合替换为（已修改的）克隆对象

首次创建时，此类的对象默认为“慢速”模式，在该模式下，所有类型的所有访问都将同步，但不会进行克隆。这适用于最初填充集合，然后setFast(true)在初始化完成后切换到“快速”模式（通过调用）。

注意：如果HashMap仅在单个线程中创建和访问一个 线程，则应java.util.HashMap直接使用 （无同步），以实现最佳性能。

put过程：

/**
 * 单线程下是Fast模式。对hashMap进行克隆，此时如果扩容，那么由克隆对象提供读服务。之后就是克隆对象和原始对象数据交换。
 */
public Object put(Object key, Object value) {
        if (fast) {
            synchronized (this) {
                HashMap temp = (HashMap) map.clone();
                Object result = temp.put(key, value);
                map = temp;
                return (result);
            }
        } else {
            synchronized (map) {
                return (map.put(key, value));
            }
        }
    }

FastHashMap是同步的。在单线程下HashMap才是高效的实现。克隆属于浅克隆。

io.netty.util.collection.IntObjectHashMap

		<dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.48.Final</version>
        </dependency>

区别并不仅仅在于int 换 Integer的那点空间，而是整个存储结构和Hash冲突的解决方法都不一样。

HashMap的结构是 Node[] table; Node 下面有Hash，Key，Value，Next四个属性。

而IntObjectHashMap的结构是int[] keys 和 Object[] values.

在插入时，同样把int先取模落桶，如果遇到冲突，则不采样HashMap的链地址法，而是用开放地址法（线性探测法）index＋1找下一个空桶，最后在keys[index]，values[index]中分别记录。在查找时也是先落桶，然后在key[index++]中逐个比较key。

所以，对比整个数据结构，省的不止是int vs Integer，还有每个Node的内容。

public V put(int key, V value) {
		//线性探测计算下一个元素的索引index+1
        int startIndex = hashIndex(key);
        int index = startIndex;

        for (;;) {
            if (values[index] == null) {
                // Found empty slot, use it.
                keys[index] = key;
                values[index] = toInternal(value);
                growSize();
                return null;
            }
            if (keys[index] == key) {
                // Found existing entry with this key, just replace the value.
                V previousValue = values[index];
                values[index] = toInternal(value);
                return toExternal(previousValue);
            }

            // Conflict, keep probing ...
            if ((index = probeNext(index)) == startIndex) {
                // Can only happen if the map was full at MAX_ARRAY_SIZE and couldn't grow.
                throw new IllegalStateException("Unable to insert");
            }
        }
    }

性能测试比对