Hashtable源码分析

前言：Hashtable线程安全的集合类，虽然它线程安全，然而在日常开发中使用的频率很低，毕竟锁的颗粒度太大了。但是这并不妨碍我们对其内部原理进行了解。

注：本文jdk源码版本为jdk1.8.0_172。

---

1.Hashtable基本概念

Hashtable与HashMap一样，都是以键值对的形式存储数据。但是Hashtable的键值不能为null，而HashMap的键值是可以为null的。Hashtable线程安全，因为它的元素操作方法上都加了synchronized关键字，这就导致锁的粒度太大，因此日常开发中一般建议使用ConcurrentHashMap。注意Hashtable的映射关系不是有序的，毕竟是以hashCode散列存储。

首先来看Hashtable的继承关系：

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable

Hashtable继承了Dictionary，实现了Map、Cloneable、Serializable接口。

HashTable构造函数

Hashtable共有4个构造函数。

#1.默认构造函数

 public Hashtable() {
        this(11, 0.75f);
    }

分析：

从默认构造函数可知：Hashtable的默认容量为11，扩容因子为0.75。

#2.确定容量的构造函数

  public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }

其他构造函数可翻看相关源码，还是比较简单的。

2.put操作

public synchronized V put(K key, V value) {
        // Make sure the value is not null
        // 如果value值为空，直接抛出空指针异常
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the Hashtable.
        Entry<?,?> tab[] = table;
        // 如果key为null，这里同样会抛出空指针
        int hash = key.hashCode();
        // 通过hash值与table长度取余，确定元素的位置
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        // 取出当前位置上的元素        
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        // 如果当前位置上存在值，则进行循环，因为位置上的值是以链表形式存储的
        for(; entry != null ; entry = entry.next) {
            // 查找是否具有相同hash值和key的元素，有则替换
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
        // 添加元素
        addEntry(hash, key, value, index);
        return null;
    }

分析：put操作的逻辑比较简单明了，通过元素的hash值确定元素在数组上的位置，然后判断是否需要对原值进行替换，如果不进行替换则直接进行插入操作。

注意：整个put操作的流程和HashMap类似，但从以上源码可以看出Hashtable是不允许[key,value]为null。

addEntry函数（插入元素），这里会涉及扩容，因此还是很有必要看下

private void addEntry(int hash, K key, V value, int index) {
        // modCount++表示进行了修改
        modCount++;

        Entry<?,?> tab[] = table;
        // 如果元素总量大于threshold
        // threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        // 在容量不超过最大值的时候，阈值等于容量与扩容因子的乘积
        if (count >= threshold) {
            // Rehash the table if the threshold is exceeded
            // 扩容
            rehash();

            tab = table;
            hash = key.hashCode();
            // 重新计算元素的位置
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        @SuppressWarnings("unchecked")
        // 取出当前位置上的元素
        Entry<K,V> e = (Entry<K,V>) tab[index];
        // 进行插入操作，从这里可以看出新的元素总是在链表头的位置
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
    }

分析：

在该函数中涉及扩容，但是由于put操作为线程安全，所以扩容时也是线程安全的。扩容要求：当前元素个数大于等于容量与扩容因子的乘积。还有一点需注意插入的新节点总是在链表头。

接下来看下addEntry函数中的重点rehash（扩容函数）

protected void rehash() {
        // 旧的容量大小
        int oldCapacity = table.length;
        Entry<?,?>[] oldMap = table;

        // overflow-conscious code
        // 扩容后新的容量等于原来容量的2倍+1
        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;
                // 进行元素插入，注意这里是头插法，元素会倒序
                e.next = (Entry<K,V>)newMap[index];
                newMap[index] = e;
            }
        }
    }

分析：

整个扩容过程比较简单，注意新的数组大小是原来的2倍加1，还有一点比较重要扩容时插入新元素采用的是头插法，元素会进行倒序。

3.get操作

分析完put操作后，我们再来看下get操作，get操作相对来说就简单许多了

public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        // 计算元素的位置
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            // 遍历 寻找hash和key相同的元素
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        // 如果未发现元素，则返回null
        return null;
    }

分析：

get操作比较简单，通过hash值与key进行查找，找到立即返回，未找到则返回null。

总结

本文对Hashtable的主要源码进行了分析，总体来看Hashtable还是比较简单，这里总结一下侧重点：

#1.Hashtable线程安全、元素无序（因为以hashCode为基准进行散列存储），不允许[key，value]为null。

#2.Hashtable默认容量为11，与HashMap不同（默认容量16），扩容时容量增长为2*n+1（HashMap直接增长为2倍）。

#3.扩容转移元素时采用的是头插法。

---

by Shawn Chen，2019.08.20日，晚上。