HashTable 源码解读

Posted arax

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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;
}

以上是关于HashTable 源码解读的主要内容,如果未能解决你的问题,请参考以下文章

深入理解JAVA集合系列二:ConcurrentHashMap源码解读

深入理解JAVA集合系列二:ConcurrentHashMap源码解读

ConcurrentHashMap源码解读

#yyds干货盘点# mybatis源码解读:executor包(语句处理功能)

Map 综述:彻头彻尾理解 HashTable

HashTable源码分析