Java源码详解三：Hashtable源码分析--openjdk java 11源码

本系列是Java详解，专栏地址：Java源码分析

Hashtable官方文档：Hashtable (Java Platform SE 8 )
Hashtable.java源码共1522行,下载地址见我的文章：Java源码下载和阅读（JDK1.8/Java 11)

文件地址：openjdk-jdk11u-jdk-11.0.6-3/src/java.base/share/classes/java/util

想看Hashtable源码的一个重要的原因是：HashMap不是线程安全的，Hashtable是线程安全的
我很好奇Hashtable如何实现线程安全。

注释

看源码的第一步是看代码开始前的注释，注释里提到几个点：

1.key和value不能为null。
2.key的类必须实现hashCode和equals方法。注释是说must，这点存疑。
3.有2个参数影响Hashtable实例的性能，分别是initial capacity和load factor。capacity就是Hashtable有多少个buckets,桶。load factor是Hashtable有多满的时候会进行自动扩容。more的load factor为0.75，较高的值会减少空间开销，但会增加查找的时间成本。
4.Hashtable处理哈希冲突的方法是在一个桶里放多个实例。
5.iterator迭代器支持fail-fast，也就是说在迭代器创建后，如果Hashtable的结构发生了变化，迭代器会抛出异常ConcurrentModificationException。迭代器不会冒风险继续迭代。fail-fast并不能做出完全的保证，用户不应该完全依赖该异常。但keys和elements方法并不是fail-fast的。
6.Hashtable是线程安全的，如果不需要线程安全，推荐使用HashMap。如果需要线程安全，推荐ConcurrentHashMap。总之不推荐Hashtable。

类的继承如下：

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

使用默认的构造函数：

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

默认的初始initialCapacity为11，load factor为0.75。
这里就和HashMap不同了，HashMap的capacity必须要是2的幂次。
对capacity的要求不同是因为采用了不同的哈希映射的方法。
HashTable默认的初始大小为11，之后每次扩充为原来的2n+1。
HashTable会尽量使用素数、奇数。当哈希表的大小为素数时，简单的取模哈希的结果会更加均匀

哈希算法与映射

Hashtable做法如下：

int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;// & 0x7FFFFFFF是为了让结果为正数

HashMap做法如下：

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

Hashtable的代码是多年前的，HashMap的做法更优，主要是因为按位与比除法快。当然缺点就是哈希函数必须设计的很好，因此对hashCode的结果进行了位移操作。

线程安全的实现方法

Hashtable实现线程安全的方法是把大部分public的方法前都加上关键字synchronized。
真是简单粗暴的做法。

put 操作

put操作是synchronized的，具体的思路跟HashMap基本一样。
1.key或value为null抛出异常
2.算出哈希，映射到数组下标
3.如果存在一样的key，直接替换value
4.不存在的话，在最后加上新的节点，有人把这个方法叫做"拉链法"。
5.扩容的话，容量*2+1。

    public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }

        addEntry(hash, key, value, index);
        return null;
    }
    private void addEntry(int hash, K key, V value, int index) {
        Entry<?,?> tab[] = table;
        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++;
        modCount++;
    }

get操作

代码很简单，不分析了：

    @SuppressWarnings("unchecked")
    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) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
    }

参考：

• java - Why is the initialCapacity of Hashtable 11 while the DEFAULT_INITIAL_CAPACITY in HashMap is 16 and requires a power of 2? - Stack Overflow
• HashMap和HashTable到底哪不同？
• 带你深入浅出的分析 HashTable 源码