概要
HashTable也是散列表的一种实现，我们在上一篇解析了HashMap,在这里我们与HashMap做个对比，让你能清晰的了解两者的区别:
| 散列表 | 实现方式 | 数据安全 | 数据安全实现方式 | keyvalue是否可为Null |
|---|---|---|---|---|
| HashMap | 数组+单向链表+红黑树 | 不安全 | 无 | 可为Null |
| HashTable | 数组+单向链表 | 安全 | Synchronized | 不可为 Null |
HashTable
1.继承关系
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable
2.常量&构造方法
/** * The hash table data. */ private transient HashtableEntry<?,?>[] table; //HashTable条目数总量 private transient int count; //下次扩容量 private int threshold; //负载因子 private float loadFactor; //修改次数 private transient int modCount = 0; //默认的构造函数 public Hashtable() { this(11, 0.75f); } //指定容量大小 public Hashtable(int initialCapacity) { this(initialCapacity, 0.75f); } //指定容量大小和负载因子大小 public Hashtable(int initialCapacity, float loadFactor) { //指定的容量大小不可以小于0,否则将抛出IllegalArgumentException异常 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); ////指定的负载因子不可以小于0或为Null，若判定成立则抛出IllegalArgumentException异常 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal Load: "+loadFactor); //若指定的容量大小为0,则赋为1 即容量初始大小最小为 1 if (initialCapacity==0) initialCapacity = 1; this.loadFactor = loadFactor; //声明table实例 table = new HashtableEntry<?,?>[initialCapacity]; //下次扩容量长度 threshold = (int)Math.min(initialCapacity, MAX_ARRAY_SIZE + 1); } //传入一个Map集合,将Map集合中元素Map.Entry全部添加进HashTable实例中 public Hashtable(Map<? extends K, ? extends V> t) { this(Math.max(2*t.size(), 11), 0.75f); putAll(t); }
3.HashtableEntry单向链表的实现
private static class HashtableEntry<K,V> implements Map.Entry<K,V> { // END Android-changed: Renamed Entry -> HashtableEntry. final int hash; final K key; V value; HashtableEntry<K,V> next; //构造函数 protected HashtableEntry(int hash, K key, V value, HashtableEntry<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } @SuppressWarnings("unchecked") protected Object clone() { return new HashtableEntry<>(hash, key, value, (next==null ? null : (HashtableEntry<K,V>) next.clone())); } // Map.Entry Ops //获取key public K getKey() { return key; } //获取value public V getValue() { return value; } //设置value public V setValue(V value) { if (value == null) throw new NullPointerException(); V oldValue = this.value; this.value = value; return oldValue; } //equals对比 public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<?,?> e = (Map.Entry<?,?>)o; return (key==null ? e.getKey()==null : key.equals(e.getKey())) && (value==null ? e.getValue()==null : value.equals(e.getValue())); } //获取hash值 public int hashCode() { return hash ^ Objects.hashCode(value); } public String toString() { return key.toString()+"="+value.toString(); } }
4.Hashtable put函数源码实现
//这里使用Synchronized锁方法的方式来保证put方法的在多线程下的数据安全 public synchronized V put(K key, V value) { // 确定value值不可为null if (value == null) { throw new NullPointerException(); } // 确定key已经在table中存在 HashtableEntry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; @SuppressWarnings("unchecked") HashtableEntry<K,V> entry = (HashtableEntry<K,V>)tab[index]; //通过for循环,查找符合条件的key，赋予新的Value for(; entry != null ; entry = entry.next) { if ((entry.hash == hash) && entry.key.equals(key)) { V old = entry.value; entry.value = value; return old; } } //添加新的Entry addEntry(hash, key, value, index); return null; } private void addEntry(int hash, K key, V value, int index) { //修改次数+1 modCount++; HashtableEntry<?,?> tab[] = table; //如果HashTable的子条目大小 大于 下次扩容大小 if (count >= threshold) { // 如果超过阈值，则重新组织HashTable 即对HashTable进行扩容 rehash(); tab = table; hash = key.hashCode(); index = (hash & 0x7FFFFFFF) % tab.length; } // Creates the new entry. @SuppressWarnings("unchecked") //将tab中索引位置下的Entry赋予 e HashtableEntry<K,V> e = (HashtableEntry<K,V>) tab[index]; //创建新的HashtableEntry赋予tab中索引位置 tab[index] = new HashtableEntry<>(hash, key, value, e); //table的条目树+1 count++; }
梳理以下HashTable.put函数的执行过程
- 1.确定value值不可为null
- 2.若key已经在table中存在，通过for循环,查找符合条件的key，赋予新的Value 返回 旧值
- 3.若不存在则进行新增操作;
- 3.1 修改次数+1，判断HashTable是否需要扩容
- 3.2 获取tab索引下的Entry 赋给 e
- 3.3 创建一个HashTableEntry赋给tab指定索引位置
- 3.4 tab的条目数 +1
5.Hashtable get函数源码实现
//这里使用Synchronized 锁方法的方式来保证get函数在多线程下的数据安全 public synchronized V get(Object key) { HashtableEntry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; //通过for循环来查找如何条件的value for (HashtableEntry<?,?> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return (V)e.value; } } return null; }
6.Hashtable rehash函数源码实现
protected void rehash() { int oldCapacity = table.length; HashtableEntry<?,?>[] oldMap = table; // 旧表长度 二进制左移1位+1 当作新表的长度 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; } HashtableEntry<?,?>[] newMap = new HashtableEntry<?,?>[newCapacity]; //修改次数+1 modCount++; //记录下次扩容量 threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1); //将新表赋予当前操作表 table = newMap; //通过for循环将旧表数据赋予新表中 for (int i = oldCapacity ; i-- > 0 ;) { //通过for循环遍历老表索引下的节点数据,赋予新表中 for (HashtableEntry<K,V> old = (HashtableEntry<K,V>)oldMap[i] ; old != null ; ) { HashtableEntry<K,V> e = old; //将老表的下一个节点重新赋给old old = old.next; int index = (e.hash & 0x7FFFFFFF) % newCapacity; e.next = (HashtableEntry<K,V>)newMap[index]; //赋予新表的指定索引位置 newMap[index] = e; } } }
结束分析
- 通过上面的分析我们可以清楚地知道,HashTable的put函数和get函数在多线程下可以保证数据安全,实现方式都是使用Synchronized 同步锁 锁方法的方式实现的,而相对于HashMap是没有采取任何方式保证数据安全,所以HashMap在多线程下无法保证数据安全.
- 也同样由于HashTable采用Synchronized同步锁 锁方法方式 锁住了整个table保证数据安全,在多线程竞争激烈的情况下效率非常低;因为线程访问同步时,其他线程访问HashTable的同步方法时可能会进入阻塞或轮询状态.