HashTable源码分析

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方法

推荐阅读更多精彩内容