一口气搞定Hashtable、HashMap、HashSet、TreeMap、LinkedHashMap、ConcurrentMap的底层，它们之间有什么不同？
散列表在我们工作中也是非常常用的一种数据结构，了解底层不仅有助于我们在工作中深度解决问题的能力，而且可以帮助我们开拓自己的思路，提高自己的代码质量。今天我们就来看看Hashtable、HashMap、TreeMap、ConcurrentMap，它们的底层究竟是怎样的，它们之间有什么区别，它们都适用于什么样的工作负载？带着以上的几点疑问，我们一起来看看。
先来看看HashTable，我们依照以前的老套路，看看它的增加方法。
//我们可以看到，它put的时候有一个同步锁的操作，这无疑会增加额外的性能开销。
//这也就是为什么它不被经常使用的一个原因
public synchronized V put(K key, V value) {
// Hashtable不支持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 entry = (Entry)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;
}
Hashtable你可能还会有这样的疑问，那么在多线程环境下是不是可以使用它了？很不错，是可以使用它，不过jdk的开发者为我们提供了一套更好的解决方案——ConcurrentMap，别急，待会稍后再介绍它。
我们再来看看HashMap它的底层，这个在开发中用的非常频繁，jdk1.8的Map做了一次优化，它在处理Hash冲突的时候，为了避免浪费大量的空间，为我们下挂了一个红黑树，因此我们先来看看jdk1.7的时候它的是怎样的。
由此可见，HashMap它是数组 + 链表构称的，我们再来看看它的实现。
这是 HashMap 中比较核心的几个成员变量；看看分别是什么意思？
1、初始化桶大小，因为底层是数组，所以这是数组默认的大小。
2、桶最大值。
3、默认的负载因子（0.75）
4、table 真正存放数据的数组。
5、Map 存放数量的大小。
6、桶大小，可在初始化时显式指定。
7、负载因子，可在初始化时显式指定。
这里需要注意的是，如果我们开发中需要装进Map的数据量比较大的时候，建议提前预估HashMap的大小最好，因为当Map的数量达到了16 * 0.75 =12的时候，就需要对当前的16进行扩容，而这个过程涉及到了rehash、复制数据等操作，是十分消耗性能的。
根据代码，我们可以看到真正存放数据的其实是
transient Entry[] table = (Entry[]) EMPTY_TABLE;
那么这个数组是如何定义的呢？
Entry 是 HashMap 中的一个内部类，从他的成员变量很容易看出：
key 就是写入时的键。
value 自然就是值。
开始的时候就提到 HashMap 是由数组和链表组成，所以这个 next 就是用于实现链表结构。
hash 存放的是当前 key 的 hashcode。
知晓了基本结构，那来看看其中重要的写入、获取函数：
put方法
public V put(K key, V value) {
//判断当前数组是否需要初始化
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//如果key值为空，则put一个空值进去
if (key == null)
return putForNullKey(value);
//根据key计算出hashcode
int hash = hash(key);
//根据计算出的hashcode定位出所在的桶
int i = indexFor(hash, table.length);
//如果是一个链表则需要遍历里面的hashcode、key是否和传入的key值相等
//如果相等则进行覆盖，并返回原来的值
for (Entry 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++;
//如果桶是空的，说明当前位置没有数据存入；
//新增一个 Entry 对象写入当前位置。
addEntry(hash, key, value, i);
return null;
}
//当调用addEntry写入Entry时，需要判断是否需要扩容
void addEntry(int hash, K key, V value, int bucketIndex) {
//如果需要则进行2倍扩充，并且当前的key重新hash并定位
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
//而在createEntry中会将当前位置的桶传入新建的桶中，如果当前桶有值就会在形成链表
createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
看看它的get函数
public V get(Object key) {
if (key == null)
return getForNullKey();
//调用下面的方法
Entry entry = getEntry(key);
//不是链表就根据 key、key 的 hashcode 是否相等来返回值。
return null == entry ? null : entry.getValue();
}
//
final Entry getEntry(Object key) {
if (size == 0) {
return null;
}
//首先它仍然是先计算出hashcode的值，然后定位到具体的桶中
int hash = (key == null) ? 0 : hash(key);
//为链表则需要遍历直到 key 及 hashcode 相等时候就返回值。
for (Entry e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
//啥都没取到就直接返回 null 。
return null;
}
不知道大家发现了1.7需要优化的地方在哪没有，当Hash冲突严重的时候，在桶上形成的链表会变的越来越长，一方面白白的浪费的大量的存储空间，另一方面我们在做查询效率的时候会大大降低，时间复杂度为O(n)。因此在jdk1.8的时候重点优化了这个方面，我们来看看到了jdk1.8的时候，HashMap的变化。
1.8HashMap结构图
先来看看几个核心的成员变量：
在这里插入代码片
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int TREEIFY_THRESHOLD = 8;
transient Node[] table;
/**
* Holds cached entrySet(). Note that AbstractMap fields are used
* for keySet() and values().
*/
transient Set> entrySet;
/**
* The number of key-value mappings contained in this map.
*/
transient int size;
和1.7的时候大致差不多，还是有几个重要的区别的：
1、TREEIFY_THRESHOLD 用于判断是否需要将链表转换为红黑树的阈值。
2、HashEntry 修改为 Node。
Node的核心组成其实也和1.7中的HashEntry一样，存放的都是key、value、hashcode、next等数据。
再来看看核心方法
put方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
//判断当前桶是否为空，空的就需要初始化（resize 中会判断是否进行初始化）。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//根据当前 key 的 hashcode 定位到具体的桶中并判断是否为空
//为空表明没有 Hash 冲突就直接在当前位置创建一个新桶即可。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node e; K k;
//如果当前桶有值（ Hash 冲突），那么就要比较当前桶中的 key、key 的 hashcode 与写入的 key 是否相等
//相等就赋值给 e,在第 8 步的时候会统一进行赋值及返回。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果当前桶为红黑树，那就要按照红黑树的方式写入数据。
else if (p instanceof TreeNode)
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
else {
//如果是个链表，就需要将当前的 key、value 封装成一个新节点写入到当前桶的后面（形成链表）。
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//接着判断当前链表的大小是否大于预设的阈值，大于时就要转换为红黑树。
//注意，虽然默认的阈值是8，看到这里它进行了一个减1的操作，也就是说当大于或等于7的时候，就会转换成红黑树了。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果在遍历过程中找到 key 相同时直接退出遍历。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果 e != null 就相当于存在相同的 key,那就需要将值覆盖。
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;
}
get方法
public V get(Object key) {
Node e;
//首先将 key hash 之后取得所定位的桶。
//如果桶为空则直接返回 null 。
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node getNode(int hash, Object key) {
Node[] tab; Node first, e; int n; K k;
//否则判断桶的第一个位置(有可能是链表、红黑树)的 key 是否为查询的 key，是就直接返回 value。
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)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;
}
从这两个核心方法（get/put）可以看出 1.8 中对大链表做了优化，修改为红黑树之后查询效率直接提高到了 O(logn)。
我们再来看看它的遍历的方式
Iterator> entryIterator = map.entrySet().iterator();
while (entryIterator.hasNext()) {
Map.Entry next = entryIterator.next();
System.out.println("key=" + next.getKey() + " value=" + next.getValue());
}
Iterator iterator = map.keySet().iterator();
while (iterator.hasNext()){
String key = iterator.next();
System.out.println("key=" + key + " value=" + map.get(key));
}
map.forEach((key,value)->{
System.out.println("key=" + key + " value=" + value);
});
这里我就不做过多的数据展示了，大家可以自行去测试一下效率。
第一种可以把 key value 同时取出
第二种还得需要通过 key 取一次 value，效率较低,
第三种需要 JDK1.8 以上（lambda表达式），通过外层遍历 table，内层遍历链表或红黑树。
不过我是强烈建议使用第一种 EntrySet 进行遍历，一方面是效率确实不错，另一方面也是我们广为熟知的。 lambda表达式我还没有具体测试过，深入的学习后，我会有专门的文章来介绍它。
再来回到 HashMap这里，它原有的问题也都存在，比如在并发场景下使用时容易出现死循环。例如我们调用 resize() 方法里的 rehash() 时，容易出现环形链表。这样当获取一个不存在的 key 时，计算出的 index 正好是环形链表的下标时就会出现死循环。
简单总结下 HashMap：无论是 1.7 还是 1.8 其实都能看出 JDK 没有对它做任何的同步操作，所以并发会出问题，甚至 1.7 中出现死循环导致系统不可用（1.8 已经修复死循环问题），这个问题jdk的开发者针对这种场景，也给出了方案，也就是ConcurrentMap。不过我认为HashMap这个问题，因为在此之前它已经是声明了，它本身是线程不安全的数据结构，造成这种原因也是操作者本身使用不当造成的。
接下来我们来看看HashSet
HashSet 是一个不允许存储重复元素的集合，它的实现比较简单，只要理解了 HashMap，HashSet 就水到渠成了。
成员变量
首先了解下 HashSet 的成员变量:
private transient HashMap map;
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
发现主要就两个变量:
- map ：用于存放最终数据的。
- PRESENT ：是所有写入 map 的 value 值。
构造函数
public HashSet() {
map = new HashMap<>();
}
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
构造函数很简单，利用了 HashMap 初始化了 map 。
//增加方法
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
比较关键的就是这个 add() 方法。
可以看出它是将存放的对象当做了 HashMap 的健，value 都是相同的 PRESENT 。由于 HashMap 的 key 是不能重复的，所以每当有重复的值写入到 HashSet 时，value 会被覆盖，但 key 不会受到影响，这样就保证了 HashSet 中只能存放不重复的元素。
总结
HashSet 的原理比较简单，但是它的顶层接口是Collection，不是Map，不过它几乎全部借助于 HashMap 来实现的。所以 HashMap 会出现的问题 HashSet 依然不能避免。
坚持住啊，就差两个了，我们来看看TreeMap
public V put(K key, V value) {
Entry t = root;1
//判断它是否为空
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry parent;
// 按照比较的结果进行排序
Comparator cpr = comparator;
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
//按照类似的结果进行排序
Comparable k = (Comparable) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
总结：
TreeMap则是基于红黑树的一种提供顺序访问的Map，和HashMap不同，它的get、put、remove之类操作都是O（log(n)）的时间复杂度，具体顺序可以由指定
的Comparator来决定，或者根据键的自然顺序来判断。
LinkedHashMap通常提供的是遍历顺序符合插入顺序，因为它本质上还是链表，它的实现是通过为条目（键值对）维护一个双向链表。注意，通过特定构造函数，我们可以创建反映访问顺序的实例，所谓的put、get、compute等，都算作“访问”。这种行为适用于一些特定应用场景，例如，我们构建一个空间占用敏感的资源池，希望可以自动将最不常被访问的对象释放掉，这就可以利用LinkedHashMap提供的机制来实现。
参考下面的示例
import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapSample {
public satic void main(String[] args) {
LinkedHashMap accessOrderedMap = new LinkedHashMap<>(16, 0.75F, true){
@Override
protected boolean removeEldesEntry(Map.Entry eldes) { // 实现自定义删除策略，否则行为就和普遍Map没有区别
return size() > 3;
}
};
accessOrderedMap.put("Project1", "Valhalla");
accessOrderedMap.put("Project2", "Panama");
accessOrderedMap.put("Project3", "Loom");
accessOrderedMap.forEach( (k,v) -> {
Sysem.out.println(k +":" + v);
});
// 模拟访问
accessOrderedMap.get("Project2");
accessOrderedMap.get("Project2");
accessOrderedMap.get("Project3");
Sysem.out.println("Iterate over should be not afected:");
accessOrderedMap.forEach( (k,v) -> {
Sysem.out.println(k +":" + v);
});
// 触发删除
accessOrderedMap.put("Project4", "Mission Control");
Sysem.out.println("Oldes entry should be removed:");
accessOrderedMap.forEach( (k,v) -> {// 遍历顺序不变
Sysem.out.println(k +":" + v);
});
}
}
我们来看看LinkedHashMap的源码
/**
* The head of the doubly linked list.
*/
private transient Entry header;
/**
* The iteration ordering method for this linked hash map: true
* for access-order, false for insertion-order.
*
* @serial
*/
private final boolean accessOrder;
private static class Entry extends HashMap.Entry {
// These fields comprise the doubly linked list used for iteration.
Entry before, after;
Entry(int hash, K key, V value, HashMap.Entry next) {
super(hash, key, value, next);
}
}
其中 Entry 继承于 HashMap 的 Entry，并新增了上下节点的指针，也就形成了双向链表。
还有一个 header 的成员变量，是这个双向链表的头结点。
上边的 demo 总结成一张图如下：
第一个类似于 HashMap 的结构，利用 Entry 中的 next 指针进行关联。
下边则是 LinkedHashMap 如何达到有序的关键。
就是利用了头节点和其余的各个节点之间通过 Entry 中的 after 和 before 指针进行关联。
其中还有一个 accessOrder 成员变量，默认是 false，默认按照插入顺序排序，为 true 时按照访问顺序排序，也可以调用:
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
这个构造方法可以显示的传入 accessOrder。
构造方法
LinkedHashMap 的构造方法:
public LinkedHashMap() {
super();
accessOrder = false;
}
其实就是调用的 HashMap 的构造方法:
HashMap 实现：
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;
threshold = initialCapacity;
//HashMap 只是定义了改方法，具体实现交给了 LinkedHashMap
init();
}
可以看到里面有一个空的 init()，具体是由 LinkedHashMap 来实现的：
@Override
void init() {
header = new Entry<>(-1, null, null, null);
header.before = header.after = header;
}
其实也就是对 header 进行了初始化。
put() 方法
看 LinkedHashMap 的 put() 方法之前先看看 HashMap 的 put 方法：
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 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;
//空实现，交给 LinkedHashMap 自己实现
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// LinkedHashMap 对其重写
addEntry(hash, key, value, i);
return null;
}
// LinkedHashMap 对其重写
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
// LinkedHashMap 对其重写
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
主体的实现都是借助于 HashMap 来完成的，只是对其中的 recordAccess(), addEntry(), createEntry() 进行了重写。
LinkedHashMap 的实现：
//就是判断是否是根据访问顺序排序，如果是则需要将当前这个 Entry 移动到链表的末尾
void recordAccess(HashMap m) {
LinkedHashMap lm = (LinkedHashMap)m;
if (lm.accessOrder) {
lm.modCount++;
remove();
addBefore(lm.header);
}
}
//调用了 HashMap 的实现，并判断是否需要删除最少使用的 Entry(默认不删除)
void addEntry(int hash, K key, V value, int bucketIndex) {
super.addEntry(hash, key, value, bucketIndex);
// Remove eldest entry if instructed
Entry eldest = header.after;
if (removeEldestEntry(eldest)) {
removeEntryForKey(eldest.key);
}
}
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMap.Entry old = table[bucketIndex];
Entry e = new Entry<>(hash, key, value, old);
//就多了这一步，将新增的 Entry 加入到 header 双向链表中
table[bucketIndex] = e;
e.addBefore(header);
size++;
}
//写入到双向链表中
private void addBefore(Entry existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
get 方法
LinkedHashMap 的 get() 方法也重写了：
public V get(Object key) {
Entry e = (Entry)getEntry(key);
if (e == null)
return null;
//多了一个判断是否是按照访问顺序排序，是则将当前的 Entry 移动到链表头部。
e.recordAccess(this);
return e.value;
}
void recordAccess(HashMap m) {
LinkedHashMap lm = (LinkedHashMap)m;
if (lm.accessOrder) {
lm.modCount++;
//删除
remove();
//添加到头部
addBefore(lm.header);
}
}
clear() 清空就要比较简单了：
//只需要把指针都指向自己即可，原本那些 Entry 没有引用之后就会被 JVM 自动回收。
public void clear() {
super.clear();
header.before = header.after = header;
}
我们来看看最后一个，ConcurrentMap。
ConcurrentHashMap 同样也分为 1.7 、1.8 版，两者在实现上略有不同。
如图所示，是由 Segment 数组、HashEntry 组成，和 HashMap 一样，仍然是数组加链表。
它的核心成员变量：
**
* Segment 数组，存放数据时首先需要定位到具体的 Segment 中。
*/
final Segment[] segments;
transient Set keySet;
transient Set> entrySet;
Segment 是 ConcurrentHashMap 的一个内部类，主要的组成如下：
static final class Segment extends ReentrantLock implements Serializable {
private static final long serialVersionUID = 2249069246763182397L;
// 和 HashMap 中的 HashEntry 作用一样，真正存放数据的桶
transient volatile HashEntry[] table;
transient int count;
transient int modCount;
transient int threshold;
final float loadFactor;
}
看看其中 HashEntry 的组成：
和 HashMap 非常类似，唯一的区别就是其中的核心数据如 value ，以及链表都是 volatile 修饰的，保证了获取时的可见性。
原理上来说：ConcurrentHashMap 采用了分段锁技术，其中 Segment 继承于 ReentrantLock。不会像 HashTable 那样不管是 put 还是 get 操作都需要做同步处理，理论上 ConcurrentHashMap 支持 CurrencyLevel (Segment 数组数量)的线程并发。每当一个线程占用锁访问一个 Segment 时，不会影响到其他的 Segment。
下面也来看看核心的 put get 方法。
put 方法
public V put(K key, V value) {
Segment s;
if (value == null)
throw new NullPointerException();
int hash = hash(key);
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);
return s.put(key, hash, value, false);
}
首先是通过 key 定位到 Segment，之后在对应的 Segment 中进行具体的 put。
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
HashEntry node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry first = entryAt(tab, index);
for (HashEntry e = first;;) {
if (e != null) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next;
}
else {
if (node != null)
node.setNext(first);
else
node = new HashEntry(hash, key, value, first);
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
else
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}
虽然 HashEntry 中的 value 是用 volatile 关键词修饰的，但是并不能保证并发的原子性，所以 put 操作时仍然需要加锁处理。
首先第一步的时候会尝试获取锁，如果获取失败肯定就有其他线程存在竞争，则利用 scanAndLockForPut() 自旋获取锁。
1、尝试自旋获取锁。
2、如果重试的次数达到了 MAX_SCAN_RETRIES 则改为阻塞锁获取，保证能获取成功。
再结合图看看 put 的流程。
1、将当前 Segment 中的 table 通过 key 的 hashcode 定位到 HashEntry。
2、遍历该 HashEntry，如果不为空则判断传入的 key 和当前遍历的 key 是否相等，相等则覆盖旧的 value。
3、不为空则需要新建一个 HashEntry 并加入到 Segment 中，同时会先判断是否需要扩容。
4、最后会解除在 1 中所获取当前 Segment 的锁。
get 方法
public V get(Object key) {
Segment s; // manually integrate access methods to reduce overhead
HashEntry[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
for (HashEntry e = (HashEntry) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
get 逻辑比较简单：
只需要将 Key 通过 Hash 之后定位到具体的 Segment ，再通过一次 Hash 定位到具体的元素上。
由于 HashEntry 中的 value 属性是用 volatile 关键词修饰的，保证了内存可见性，所以每次获取时都是最新值。
ConcurrentHashMap 的 get 方法是非常高效的，因为整个过程都不需要加锁。
1.7 已经解决了并发问题，并且能支持 N 个 Segment 这么多次数的并发，但依然存在 HashMap 在 1.7 版本中的问题。
那就是查询遍历链表效率太低。
因此 1.8 做了一些数据结构上的调整。
首先来看下底层的组成结构：
看起来是不是和 1.8 HashMap 结构类似？
其中抛弃了原有的 Segment 分段锁，而采用了 CAS + synchronized 来保证并发安全性。
static class Node implements Map.Entry {
final int hash;
final K key;
volatile V val;
volatile Node next;
Node(int hash, K key, V val, Node next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return val; }
public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
public final String toString(){ return key + "=" + val; }
public final V setValue(V value) {
throw new UnsupportedOperationException();
}
也将 1.7 中存放数据的 HashEntry 改为 Node，但作用都是相同的。
其中的 val next 都用了 volatile 修饰，保证了可见性。
put 方法
重点来看看 put 函数：
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
//根据 key 计算出 hashcode 。
int hash = spread(key.hashCode());
int binCount = 0;
for (Node[] tab = table;;) {
Node f; int n, i, fh;
//判断是否需要进行初始化。
if (tab == null || (n = tab.length) == 0)
tab = initTable();
//f 即为当前 key 定位出的 Node，如果为空表示当前位置可以写入数据
//利用 CAS 尝试写入，失败则自旋保证成功。
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null,
new Node(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//如果当前位置的 hashcode == MOVED == -1,则需要进行扩容。
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
//如果都不满足，则利用 synchronized 锁写入数据。
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node pred = e;
if ((e = e.next) == null) {
pred.next = new Node(hash, key,
value, null);
break;
}
}
}
else if (f instanceof TreeBin) {
Node p;
binCount = 2;
if ((p = ((TreeBin)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
//如果数量大于 TREEIFY_THRESHOLD 则要转换为红黑树。
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
get 方法
public V get(Object key) {
Node[] tab; Node e, p; int n, eh; K ek;
//根据计算出来的 hashcode 寻址，如果就在桶上那么直接返回值。
int h = spread(key.hashCode());
//如果是红黑树那就按照树的方式获取值。
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
//就不满足那就按照链表的方式遍历获取值。
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
总结
HashTable
Java早期提供的一个哈希表实现，由于同步的额外开销，导致它很少被使用,此外它是不支持空键和空值。
HashMap
应用更加广泛的哈希表实现，行为和HashTable大致一致，主要区别是HashMap是不同步的，支持null键和值。默认是16，负载因子为0.75，jdk1.8时候，当链表超过了8时，它会增加一颗红黑树进去。
HashSet
它不是属于Map接口下面的子类，而是属于Collection接口的子类，但是它的实现几乎完全是按照HashMap的使用而来的。当然，HashMap里面存在的问题，它也会存在的。
TreeMap
是基于红黑树的一种顺序访问的Map，和HashMap不同，它的get、put、remove之类操作都是(O(log(n)))的时间复杂度，具体顺序由Compartor决定，或者根据自然顺序来排序。
LinkedHashMap
总的来说 LinkedHashMap 其实就是对 HashMap 进行了拓展，使用了双向链表来保证了顺序性。它适用于一些特定应用场景，例如，我们构建一个空间占用敏感的资源池，希望可以自动将最不常被访问的对象释放掉，这就可以利用LinkedHashMap提供的机制来实现。因为是继承与 HashMap 的，所以一些 HashMap 存在的问题 LinkedHashMap 也会存在，比如不支持并发等。
ConcurrentHashMap
1.8 在 1.7 的数据结构上做了大的改动，采用红黑树之后可以保证查询效率（O(logn)），甚至取消了 ReentrantLock 改为了 synchronized，这样可以看出在新版的 JDK 中对 synchronized 优化是很到位的。