观察源码分析HashMap和Hashtable的区别

老生常谈的问题，有时候总是记不太清，希望今天好好总结一下。

首先打开HashMap源码：

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

可以发现Hash继承的是AbstractMap类，并且分别实现了Map接口，Cloneable和序列化接口。

再看HashTable

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

发现HashTable继承的是Dictionary（提供了一些常用方法），实现的接口和HashMap相同。

观察HashMap的无参构造方法：

   public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

再看HashTable的无参构造方法：

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

可以观察得出HashTable应该要比HashMap更加老一些。

观测其get，put等方法，发现其并没有加锁，意味着在多线程读写时可能会出现问题，但其在效率方面有所提高。

  public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

 public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }


        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

反观HashTable则对这些方法加了锁。

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

 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 = hash(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<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 the table if the threshold is exceeded
            rehash();


            tab = table;
            hash = hash(key);
            index = (hash & 0x7FFFFFFF) % tab.length;
        }


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

并且通过观察HashMap和HashTable的put方法，可以观察出，如果put的键值对中键是之前已经有的，呢么新put的value会覆盖原来的value。在看一些源码，可以发现HashTable不接受key或value为空的键值对。

HashMap和HashTable内部都是由Entry数组和其组成的链表所构成。

查找和删除都要通过key的hash值计算出Entry在数组中的位置。

他们的数组扩容方式也不一样。
另外：

 “Hashtable和HashMap的区别主要是前者是同步的，后者是快速失败机制保证不会出现多线程并发错误（Fast-Fail）。”，这是一个被很多文章转载过的概念，但其描述并不准确，容易引起误会。

实质上，Fast-fail与同步保护的是两种不同情况下的并发，两者不能拿来做比较。

Hashtable是同步的，在执行get,put,remove,size,clear等一次性读写操作时，使用了同步机制，避免了多个线程 同时读写Hashtable。但同步机制并不能避免在iterator或Enumeration遍历过程中其他线程对Hashtable的put、 remove、clear操作，这些写操作都会被毫无阻拦得成功执行。

快速失败机制主要目的在于使iterator遍历数组的线程能及时发现其他线程对Map的修改（如put、remove、clear等），因 此，fast-fail并不能保证所有情况下的多线程并发错误，只能保护iterator遍历过程中的iterator.next()与写并发.

其次，Hashtable的iterator遍历方式也是支持fast-fail的，不能说它没有快速失败机制。写一个简单的例程就可以证明这 一点，一个线程做iterator遍历，另一个线程向hashtable中put新的key和value，很容易就会观察到fast-fail 机制报告ConcurrentModificationException