一直想看集合的源码,奈何总觉得时间不够用,第一次看,先大概做个笔记,参考了一些博客和书,后面继续更新。。。
零,总括
Map是用来存储键值对的数据结构,在数组中通过数组下标来对其内容进行索引。从java源码来看,java是先实现了Map,然后通过包装一个所有value为null的Map就实现了Set集合
1.Hashtable
继承Dictionary,方法被synchronized修饰,so是一个线程安全的实现,性能略低于HashMap,使用的迭代器是Enumeration,会在别的线程修改元素的时候抛出ConcurrentModificationException异常
2.HashMap
根据键的HashCode值存储数据,使用的数据结构是链表散列(数据+链表),访问速度很快,特点是线程不安全、允许空键值。冲突解决方法是链地址法(桶的概念,对于Entry数组而言,数组每个元素存储的是链表,一个链表就是一个桶,使用addEntry方法添加新元素时总是将新元素添加在链表的表头)
扩容:当HashMap.size>=Capacity*LoadFactor时调整大小,默认扩展为两倍
3.ConcurrentHashMap
产生于JDK1.5之后,用于替代Hashtable的线程安全的HashMap。ConcurrentHashMap在线程安全的基础上提供了更好的写并发能力,但同时降低了对读一致性的要求,大量利用了volatile、final、CAS等lock-free技术来减少锁竞争对于性能的影响。在JDK6、7、8的实现都不一样,在JDK8中,利用CAS来替代之前的segment概念,底层用数组+链表+红黑树的方法实现,增加了很多辅助类来支持并发
一,Hashtable
1.继承的是Dicitionary类,实现了Map、Cloneable、Serializable接口
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable
2.几个属性
private transient Entry<?,?>[] table;//实现Hashtable借助的数组,默认大小为11
private transient int count;//记录table数组中存储元素的个数
private int threshold;//扩容的门限,即如果table中存储的元素个数大于threshold,则扩大数组table的大小
private float loadFactor;//加载因子,默认为0.75f
3.构造函数
有如下等:
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}
/**
* Constructs a new, empty hashtable with a default initial capacity (11)
* and load factor (0.75).
*/
public Hashtable() {
this(11, 0.75f);
}
但最终调用的都是这个,initialCapacity为初始容量,默认为11,;loadFactor为加载因子,默认为0.75f
public Hashtable(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal Load: "+loadFactor);
if (initialCapacity==0)
initialCapacity = 1;
this.loadFactor = loadFactor;
table = new Entry<?,?>[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
4.put函数
思想:首先检查value是否为null,若是,则抛异常。根据key的hashCode找到此元素的存储位置index,如果位置index已经有元素链表了,则在此链表中,寻找是否有key已经存在,如果存在更新value值,若不存在则将此节点插入
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;
}
}
//如果没有此key,则添加此节点
addEntry(hash, key, value, index);
return null;
}
5.addEntry,给数组table的index位置添加元素
思想:首先检查数组table元素个数是否大于扩容门限,如果大于则扩容,扩容之后,重新获取key的hashCode,并根据hashCode计算要存储的位置index,最后将要存储的数据存储到table[index]中。如果table[index]中已经有其他元素,那么同一个位子上的元素将以链表的形式存放,新加入的放在链头,先前加入的在链尾
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();
//扩容之后重新计算index
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];//获取table数组在index的元素,如果非空,则新节点放在这个结点的前面,成为新的链表头
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
6.扩容rehash
思想:扩容长度=原长度*2+1,然后新建一个newCapacity数组,将原来的table数组元素拷贝到新的数组中去
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;
}
}
}
7.get
思想:首先获取key的hashCode,根据hashCode得到存储位置index,最后在table[index]取出元素即可,注意,这里可能存储了多个元素构成了一个链表,因此要进行一个key和hash的判断
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;
}
二,HashMap
1.继承AbstractMap类,实现Map、Cloneable、Serializable接口(Hashtable继承的是Dicitionary类)
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
2.初始容量为16,最大容量为2的30次方,负载因子是0.75f
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
3.底层实现,数组+链表,Node[]就是哈希桶数组,实现了Map.Entry接口,本质就是一个映射,其长度length必须是2的n次方
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
4.构造函数
产生HashMap对象,其它的构造函数都是调用此构造函数来实现
initialCapacity:分配数组的大小,默认为16,且只能是2的幂次方
loadFactor:加载因子,当数组中存储的数据大于分配空间的总长度*loadFactor之后就进行扩容
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
5.hash方法,该哈希算法也就解释了为什么初始容量为16,并且每次自动扩展或是手动初始化时,长度必须是2的幂(服务于key到index的hash算法)
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
6.put方法,其中i = (n - 1) & hash,n为数组长度,so,HashMap的容量必须为2的幂次方
思想:
(1)判断键值对数组table[]是否为空或者null,否则resize进行扩容
(2)根据键值key计算hash值得到插入的数组索引i,如果table[i]=null,直接新建节点添加,转向(6),如果table[i]不为空,转向(3)
(3)判断table[i]的首个元素是否和key一样,如果相同直接覆盖value,否则(4),相同指hashCode和equals
(4)判断table[i]是否为treeNode,如果是红黑树,则直接在树中插入键值对,否则(5)
(5)遍历table[i],判断链表长度是否大于8,大于8的话把链表转为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作,遍历过程中若发现key已经存在,直接覆盖value即可
(6)插入成功后,判断实际存在的键值对数量size是否超过了最大容量threshold,如果超过则进行扩容
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
7.resize扩容
使用的是2次幂的扩展,即长度为原来的2倍,so,元素位置要么是在原位置,要么原位置移动2次幂的位置。因此,在扩充HashMap的时候,不需要像JDK1.7重新计算hash,只需要看原来的hash新增的那个bit是1还是0就好了,是0的话索引没变,是1的话索引变成“原索引+oldCap”,该设计非常巧妙,既省去了重新计算hash时间,同时,由于新增的1bit是1还是0认为是随机的,一次resize的过程,均匀地把之前的冲突的结点分散到新的bucket了,这就是JDK1.8新增的优点
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {//如果table是有长度的,即不是第一次使用,则会进行扩容处理
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
8.get
思想:首先根据key得到hashCode,然后根据hashCode得到该key在数组table的存储位置,接着在该位置寻找key值和hashCode值一致的结点,如果没有找到返回null
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
HashMap和Hashtable的几点区别
- 继承类不一样:HashMap继承AbstractMap,Hashtable继承的是Dictionary
- 初始容量不一样:HashMap默认为16,且智能是2的幂次方,Hashtable默认为11,容量并没有2的幂次方的限制,增加的方式是oldCap*2+1
- HashMap是线程不安全的,Hashtable通过synchronized是线程安全
- 使用的hashCode不一样:
- HashMap允许有一个key为null,多个value为null,而Hashtable不允许key和value为null
- 内部遍历方式不一样:HashMap和Hashtable都使用了Iterator,而由于历史原因,Hashtable还使用了Enumeration
三,ConcurrentHashMap
最近在看线程安全,云里雾里,从这个角度说一下吧,HashMap如何做到线程安全?一种可行的方法是使用操作集合的工具类Collections,即
Map map=Collections.synchronizedMap(new HashMap());
生成一个名为SynchronizedMap的Map,它使用委托,将自己所有Map相关的功能交给传入的HashMap实现,而自己主要负责保证线程安全,具体源码看看,首先SynchronizedMap内包装了一个Map
private static class SynchronizedMap<K,V>
implements Map<K,V>, Serializable {
private static final long serialVersionUID = 1978198479659022715L;
private final Map<K,V> m; // Backing Map
final Object mutex; // Object on which to synchronize
通过mutex实现对这个m的互斥操作,比如,get方法,以及其他相关的Map操作都会使用这个mutex进行同步保证线程安全
public V get(Object key) {
synchronized (mutex) {return m.get(key);}
}
这个包装的Map可以满足线程安全的要求,但是,它在多线程环境中的性能表现并不好,无论是对Map的读取或者写入,都需要获得mutex的锁,这会导致所有对Map的操作全部进入等待状态,直到mutex锁可用,如果并发级别不高一般也就够用,但是,在高并发环境中,需要新的解决方法,即ConcurrentHashMap
思想:锁分段,首先将数据分成一段一段地存储,然后给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据的时候,其他段的数据也能被其他线程访问
比较复杂,具体的放在多线程并发里面吧!
参考:
https://blog.csdn.net/u010412719/article/details/51980632
https://blog.csdn.net/u014282557/article/details/77756560
https://blog.csdn.net/dou_yuan/article/details/77773530