HashTable原理和底层实现

1. 概述

上次讨论了HashMap的结构，原理和实现，本文来对Map家族的另一个经常使用集合HashTable进行介绍。HashTable和HashMap两种集合很是类似，常常被各类面试官问到二者的区别。

对于二者的区别，主要有如下几点：

1. HashMap是非同步的，没有对读写等操做进行锁保护，因此是线程不安全的，在多线程场景下会出现数据不一致的问题。而HashTable是同步的，全部的读写等操做都进行了锁（synchronized）保护，在多线程环境下没有安全问题。可是锁保护也是有代价的，会对读写的效率产生较大影响。
2. HashMap结构中，是容许保存null的，Entry.key和Entry.value都可觉得null。可是HashTable中是不容许保存null的。
3. HashMap的迭代器（Iterator）是fail-fast迭代器，可是Hashtable的迭代器（enumerator）不是fail-fast的。若是有其它线程对HashMap进行的添加/删除元素，将会抛出ConcurrentModificationException，但迭代器自己的remove方法移除元素则不会抛出异常。这条一样也是Enumeration和Iterator的区别。

    

   2. 原理

   HashTable类中，保存实际数据的，依然是Entry对象。其数据结构与HashMap是相同的。
   
   HashTable类继承自Dictionary类，实现了三个接口，分别是Map，Cloneable和java.io.Serializable，以下图所示。

HashTable中的主要方法，如put，get，remove和rehash等，与HashMap中的功能相同，这里不做赘述，能够参考另一篇文章HashMap实现原理及源码分析

 

3. 源码分析

HashTable的主要方法的源码实现逻辑，与HashMap中很是类似，有一点重大区别就是全部的操做都是经过synchronized锁保护的。只有得到了对应的锁，才能进行后续的读写等操做。

 

1. put方法

put方法的主要逻辑以下：

1. 先获取synchronized锁。
2. put方法不容许null值，若是发现是null，则直接抛出异常。
3. 计算key的哈希值和index
4. 遍历对应位置的链表，若是发现已经存在相同的hash和key，则更新value，并返回旧值。
5. 若是不存在相同的key的Entry节点，则调用addEntry方法增长节点。
6. addEntry方法中，若是须要则进行扩容，以后添加新节点到链表头部。

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) {
        modCount++;

        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++;
    }

2. get方法

get方法的主要逻辑以下

1. 先获取synchronized锁。
2. 计算key的哈希值和index。
3. 在对应位置的链表中寻找具备相同hash和key的节点，返回节点的value。
4. 若是遍历结束都没有找到节点，则返回null。

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;
    }

3.rehash扩容方法

rehash扩容方法主要逻辑以下：

1. 数组长度增长一倍（若是超过上限，则设置成上限值）。
2. 更新哈希表的扩容门限值。
3. 遍历旧表中的节点，计算在新表中的index，插入到对应位置链表的头部。

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;
                e.next = (Entry<K,V>)newMap[index];
                newMap[index] = e;
            }
        }
    }

 

4. 总结

HashTable相对于HashMap的最大特色就是线程安全，全部的操做都是被synchronized锁保护的