HashTable 源码解读

很多人都知道HashTable与HashMap的关系，HashTable是线程安全的，HashMap是非线程安全的。在介绍完HashMap之后，趁热介绍一下HashTable。在HashTable中没有像HashMap中那么多关于数据结构的内容。HashTable是线程安全的，因为其源码的方法里都带有synchronized，但是效率不高，如果想使用高性能的Hash结构，建议使用java.util.concurrent.ConcurrentHashMap

HashTable 存储的数据类型

HashTable的key和value都可以为空，在存储的过程中 key必须实现 hashCode（）和equals（）两个方法。

影响HashTable性能的两个参数

HashTable中的两个变量影响其性能：初始容量与负载系数（load factor）。

容量

指的时hashtable中桶的个数。桶其实就是单向的链表。hashtable 是允许hash 冲突的，单个桶（链表）可以存储多个entry。在定义HashTable的初始容量的大小时，要权衡是空间 和 重新hash运算（很耗时）之间的利弊。当初始的容量大于元素的最大个数时，将不会发生rehash运算，但是太大的初始容量意味着浪费了很多空间。如果能提前估算出要向hashTable中存很多值时，就要给一个适合的初始容量，因为在添加数据时如，果不需要rehash操作的话将会更快。

负载系数

指的是hashtable在自动扩容之前允许桶多满？默认的负载系数为0.75，增大可以减少每次扩容的大小，但是增加了查找所花费的时间。

数据结构

前面也提到了，HashTable内部存储了一个table数组，这个数组的每一个元素存储的都是链表的头。在存储数值时，定位存储位置是通过如下代码：

    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length; // 去掉符号位的影响
    Entry<K,V> e = (Entry<K,V>)tab[index];

上面的代码就确定了当前key的节点位于哪个链表上，e 即链表头。如果在该链表中无法找到对应的key，则将当前的节点添加到链表的头部。

        Entry<K,V> e = (Entry<K,V>) tab[index];
        // 把链表的头部传进去，为了将new 出来的节点.next指向原来链表的头部
        tab[index] = new Entry<>(hash, key, value, e); 

rehash算法

rehash算法，也可以理解为扩容算法，当table装不下要存储的值的时候，这是后就需要扩容增加内部数组的长度，这下惨了，每个key存储到哪个链表中是和table.length有直接关系的，所以在扩容时，要把当前hashtable中存储的节点重新计算一遍存储位置，这就是前面提到的为什么rehash会很耗时。

protected void rehash() {
    int oldCapacity = table.length;
    Entry<?,?>[] oldMap = table;

    // overflow-conscious code
    int newCapacity = (oldCapacity << 1) + 1; // 容量每次扩大一倍
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        if (oldCapacity == MAX_ARRAY_SIZE)
            // Keep running with MAX_ARRAY_SIZE buckets
            return;
        newCapacity = MAX_ARRAY_SIZE;
    }
    Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

    modCount++; //结构变化
    threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    table = newMap;

    for (int i = oldCapacity ; i-- > 0 ;) {
        for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
            Entry<K,V> e = old; // 将当前的变量赋值给暂存变量
            old = old.next; // 继续获取链表的下一个节点，为下一次循环做准备

            int index = (e.hash & 0x7FFFFFFF) % newCapacity; // 计算当前节点在newMap中存储的位置
            // 每次插入数据都插入到链表的头
            e.next = (Entry<K,V>)newMap[index];  // 将当前节点的指针指向原来链表的头
            newMap[index] = e; // 将当且节点存入数组中
        }
    }
}

compute方法

这不是hashMap独有的，是Map接口定义的。放在这里讲的原因是：HashTable没什么好写的，正好从HashMap把这部分内容搬过来。

computeIfAbsent，computeIfPresent，compute 三个方法，这三个方法本质上都是根据给定的key更新当前map中的值，HashMap中也有同样的方法
下面是一个简短的例子

public static void main(String[] args) {
HashMap<String,Integer> map = new HashMap<>();
for (int i = 0; i< 10; i++) {
map.put(String.valueOf(i),i);
}
map.computeIfPresent(String.valueOf(5),new MyFunction()); // 如果存在则计算
System.out.println(map);

map.computeIfAbsent(String.valueOf(20),new AbsentFunciton());  //如果不存在添加
System.out.println(map);

map.compute(String.valueOf(8),new MyFunction());    //如果存在则计算，不存在添加
System.out.println(map);
}

//上面要使用的接口实现
class MyFunction implements BiFunction {

    @Override
    public Object apply(Object key, Object oldValue) {
        if (key.equals("5")) {
            return (Integer)oldValue + 3;
        }
        return oldValue;
    }
}

class AbsentFunciton implements Function{

    @Override
    public Object apply(Object key) {
        return key;
    }
}

下面对3个方法进行一下介绍

computeIfAbsent

根据给定的key 在hashtable中查找，如果找到了返回key对应的值，如果没找到，根据定义的计算功能，算出新值，如果新值不为空，添加到hashtable中

public synchronized V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
    //计算功能不能为空
    Objects.requireNonNull(mappingFunction);
    // 缓存内部table
    Entry<?,?> tab[] = table;
    // 根据给定的key 计算出hash
    int hash = key.hashCode();
    // 根据hash求出在数组第几个链上
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    Entry<K,V> e = (Entry<K,V>)tab[index];
    // 如果在链表中找到，则返回旧值
    for (; e != null; e = e.next) {
        if (e.hash == hash && e.key.equals(key)) {
            // Hashtable not accept null value
            return e.value;
        }
    }
    // 记录modCount 在计算时，不允许修改hashtable结构
    int mc = modCount;
    // 获得根据计算功能计算出的新值
    V newValue = mappingFunction.apply(key);
    if (mc != modCount) { throw new ConcurrentModificationException(); }
    // 如果新值不为空，添加到hashtable中
    if (newValue != null) {
        addEntry(hash, key, newValue, index);
    }
    // 返回新值
    return newValue;
}

computeIfPresent

根据给定的key在hashtable中查找，如果没找到，返回空，如果找到了，根据定义的功能，计算出新值，如果新值为 null，则将key对应的节点删除，如果不是空，更新节点值,最后返回新值。

public synchronized V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    //定义的计算功能不能为空
    Objects.requireNonNull(remappingFunction);
    //复制一份table
    Entry<?,?> tab[] = table;
    // 根据hash计算在hashtable中的位置
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    Entry<K,V> e = (Entry<K,V>)tab[index];
    // 在对应的位置的链表中查找
    for (Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
        if (e.hash == hash && e.key.equals(key)) {
            // 如果找到了，根据key、旧值和定义的功能计算出新值 
            int mc = modCount;
            V newValue = remappingFunction.apply(key, e.value);
            if (mc != modCount) {
                throw new ConcurrentModificationException();
            }
            // 要将新值赋值到原来的key上，如果新值为空，则要在链表上删除对应的节点，计数器-1
            if (newValue == null) {
                if (prev != null) {
                    prev.next = e.next; 
                } else {
                    tab[index] = e.next;
                }
                modCount = mc + 1;
                count--;
            } else {
                e.value = newValue;
            }
            // 返回新值
            return newValue;
        }
    }
    // 如果在对应位置上的链表中没有找到，则返回空
    return null;
}

compute

思路就是有就更新，没有就添加，是上面两个的整合。

public synchronized V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    // 定义的计算功能不能为空
    Objects.requireNonNull(remappingFunction);

    Entry<?,?> tab[] = table;
    // 根据hash获取链表位置
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    Entry<K,V> e = (Entry<K,V>)tab[index];
    如果根据key找到了对应的节点，更新对应的节点值，并返回根据功能计算的新值
    for (Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
        if (e.hash == hash && Objects.equals(e.key, key)) {
            int mc = modCount;
            V newValue = remappingFunction.apply(key, e.value);
            if (mc != modCount) {
                throw new ConcurrentModificationException();
            }
            if (newValue == null) {
                if (prev != null) {
                    prev.next = e.next;
                } else {
                    tab[index] = e.next;
                }
                modCount = mc + 1;
                count--;
            } else {
                e.value = newValue;
            }
            return newValue;
        }
    }
    // 如果没有找到根据key 计算出新值，如果新值不为空添加到table中，返回计算的新值
    int mc = modCount;
    V newValue = remappingFunction.apply(key, null);
    if (mc != modCount) { throw new ConcurrentModificationException(); }
    if (newValue != null) {
        addEntry(hash, key, newValue, index);
    }

    return newValue;
}