HashTable跟HashMap在功能上来基本类似，其解决hash冲突的方法也是基于链地址法， 唯一的不同点在HashTable的方法是同步的，多线程操作时，在外部无需使用同步机制

源码解读

1. 成员变量

    private transient HashtableEntry<K,V>[] table;

    private transient int count;


    private int threshold;

    private float loadFactor;


    private transient int modCount = 0;

HashTable的成员变量跟HashMap的成员变量类似，同样都有loadFactor, modCount, threshold

2. put

    public synchronized V put(K key, V value) {
        if (value == null) {
            throw new NullPointerException();
        }
        
        HashtableEntry tab[] = table;
        //直接调用key.hashCode()
        int hash = hash(key);
        //计算索引值
        int index = (hash & 0x7FFFFFFF) % tab.length;
        //如果已经存在key值相等的entry，用新value替换旧value
        for (HashtableEntry<K,V> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                V old = e.value;
                e.value = value;
                return old;
            }
        }
        
        modCount++;
        if (count >= threshold) {
            //扩容至之前容量的两倍
            rehash();
            tab = table;
            hash = hash(key);
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        HashtableEntry<K,V> e = tab[index];
        tab[index] = new HashtableEntry<>(hash, key, value, e);
        count++;
        return null;
    }

HashTable的put逻辑大体上与HashMap的一致，都可以总结为：

1. 计算key值的hash
2. 由hash得出索引
3. 如果已经存在key值相等的entry，用新value替换旧value
4. 递增modCount, 检查是否key-value键值对数量是否达到阈值，如果达到进行扩容操作，扩容至原先容量的两倍
5. 创建Entry, 放入数组

但是HashTable中计算hash值和索引值这两步，跟HashMap有很大区别, HashTable是直接获取了key值得hashCode()返回值，然后用求模的方式计算索引，相比于HashMap来说，不仅效率略低，同时由于HashTable并没有硬性要求容量必须是2的n次方，从而会造成index冲突的几率加大，减慢了查询的效率

另外，可以看到HashTable的put方法增加了synchronized关键字，这就意味着put方法是一个同步方法，相对于HashMap的非同步put方法，其在单线程模型下效率肯定会略低

3. get

    public synchronized V get(Object key) {
        HashtableEntry tab[] = table;
        int hash = hash(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (HashtableEntry<K,V> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return e.value;
            }
        }
        return null;
    }

get方法也是被synchronized修饰

4. 遍历HashTable

4.1 HashTable.entrySet

    public Set<Entry<K,V>> entrySet() {
        if (entrySet==null)
            entrySet = Collections.synchronizedSet(new EntrySet(), this);
        return entrySet;
    }

可以看到，获取entrySet时，调用Collections.synchronizedSet来保证Set是同步的

4.2 EntrySet.iterator

private static final int ENTRIES = 2;

public Iterator<Entry<K,V>> iterator() {
    return getIterator(ENTRIES);
}

private <T> Iterator<T> getIterator(int type) {
   if (count == 0) {
        return Collections.emptyIterator();
   } else {
        return new Enumerator<>(type, true);
    }
}

4.3 Enumerator

private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
    HashtableEntry[] table = Hashtable.this.table;
    ...
    protected int expectedModCount = modCount;
    
    public T next() {
         if (modCount != expectedModCount)
             throw new ConcurrentModificationException();
         return nextElement();
    }
    
    public T nextElement() {
         HashtableEntry<K,V> et = entry;
         int i = index;
         HashtableEntry[] t = table;
         /* Use locals for faster loop iteration */
         while (et == null && i > 0) {
             et = t[--i];
         }
         entry = et;
         index = i;
         if (et != null) {
             HashtableEntry<K,V> e = lastReturned = entry;
             entry = e.next;
             //KEYS代表要获取key的集合， VALUES代表获取value的集合，ENTIRES代表获取entry的集合
             return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
         }
         throw new NoSuchElementException("Hashtable Enumerator");
   }
}

可以看到HashTable也同样采用Fast-Fail机制，当使用迭代器遍历时，不可以调用HashTable.remove来删除元素，而是应该用迭代器自身的remove方法