1.LinkedHashMap
在之前学习的时候,迭代HashMap的顺序并不是放置的顺序,也就是无序的。为了有顺序的访问LinkedHashMap在底层为了双向链表,保证了元素迭代的顺序。该顺序可以是插入顺序和访问顺序。
1.2 基本数据结构和属性
//双向链表的头指针
transient LinkedHashMap.Entry<K,V> head;
//双向链表的尾指针
transient LinkedHashMap.Entry<K,V> tail;
//规定访问顺序,是按照访问顺序和插入顺序
final boolean accessOrder;
LinkedHashMap可以认为是HashMap+LinkedList,HashMap用作数据结构,LinkedList维护插入元素的先后顺序。
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
{
...
}
可以看的是LinkedHashMap继承了HashMap,它的一些操作就是在HashMap的基础上操作的。
LinkeHashMap相比较于HashMap的三个重要属性:
看看Entry:
private static class Entry<K,V> extends HashMap.Entry<K,V> {
// These fields comprise the doubly linked list used for iteration.
Entry<K,V> before, after;
Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
super(hash, key, value, next);
}
...
}
这里面的key,value,next,hash是从HashMap中继承过来的。后面的before和after是LinkedHashMap独有的。next是用于维护HashMap指定table位置上连接的Entry的顺序的,before、After是用于维护Entry插入的先后顺序的。
每当有新键值对节点插入,新节点最终会接在 tail 引用指向的节点后面。而 tail 引用则会移动到新的节点上,这样一个双向链表就建立起来了。
1.3 链表的建立过程
链表的建立过程是在插入键值对节点开始的,初始情况下,让LinkedHashMap的head和tail引用同时指向新节点,链表就算建立起来,随后不断有新节点插入,通过将新节点接在tail引用指向的节点后面,即可实现链表的不断更新。
inkedHashMap是继承了HashMap,所以在使用put方法插入链表,在这个方法内操作双向链表的建立。
// HashMap 中实现
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// HashMap 中实现
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) {...}
// 通过节点 hash 定位节点所在的桶位置,并检测桶中是否包含节点引用
if ((p = tab[i = (n - 1) & hash]) == 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) {...}
else {
// 遍历链表,并统计链表长度
for (int binCount = 0; ; ++binCount) {
// 未在单链表中找到要插入的节点,将新节点接在单链表的后面
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) {...}
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) {...}
afterNodeAccess(e); // 回调方法,后续说明
return oldValue;
}
}
++modCount;
if (++size > threshold) {...}
afterNodeInsertion(evict); // 回调方法,后续说明
return null;
}
// HashMap 中实现
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
// LinkedHashMap 中覆写
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
LinkedHashMap.Entry<K,V> p =
new LinkedHashMap.Entry<K,V>(hash, key, value, e);
// 将 Entry 接在双向链表的尾部
linkNodeLast(p);
return p;
}
// LinkedHashMap 中实现
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
tail = p;
// last 为 null,表明链表还未建立
if (last == null)
head = p;
else {
// 将新节点 p 接在链表尾部
p.before = last;
last.after = p;
}
}
LinkedHashMap 覆写了newNode方法。在这个方法中,LinkedHashMap 创建了 Entry,并通过 linkNodeLast 方法将 Entry 接在双向链表的尾部,实现了双向链表的建立。双向链表建立之后,我们就可以按照插入顺序去遍历 LinkedHashMap。
1.4 链表的删除方法
和插入一样,也是在父类的方法中对某个方法进行重写。
// HashMap 中实现
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
// HashMap 中实现
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode) {...}
else {
// 遍历单链表,寻找要删除的节点,并赋值给 node 变量
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode) {...}
// 将要删除的节点从单链表中移除
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node); // 调用删除回调方法进行后续操作
return node;
}
}
return null;
}
// LinkedHashMap 中覆写
void afterNodeRemoval(Node<K,V> e) { // unlink
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
// 将 p 节点的前驱后后继引用置空
p.before = p.after = null;
// b 为 null,表明 p 是头节点
if (b == null)
head = a;
else
b.after = a;
// a 为 null,表明 p 是尾节点
if (a == null)
tail = b;
else
a.before = b;
}
可以看到的是这个get的查询过程基本就是在HashMap上进行操作,然后在删除的时候覆写了一个方法。
1.5 访问顺序的维护过程
前面的put都是基于插入顺序实现的。默认情况下,LinkedHashMap是基于插入顺序维护链表。可以在初始化的时候,指定accessOrder参数为true。让其按照访问顺序维护链表。当我们调用get/getOrDefault/replace方法,只需要将这些方法访问的节点移动到链表的尾部。
// LinkedHashMap 中覆写
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
// 如果 accessOrder 为 true,则调用 afterNodeAccess 将被访问节点移动到链表最后
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
// LinkedHashMap 中覆写
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
p.after = null;
// 如果 b 为 null,表明 p 为头节点
if (b == null)
head = a;
else
b.after = a;
if (a != null)
a.before = b;
else
last = b;
if (last == null)
head = p;
else {
// 将 p 接在链表的最后
p.before = last;
last.after = p;
}
tail = p;
++modCount;
}
}
1.6 使用LinkedHashMap实现LRU
在上面维护访问顺序的时候知道,每次都会把最近一次访问的节点放在双向链表的尾结点。所以双向链表的头节点就是最近最久没有访问过的节点。
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
// 根据条件判断是否移除最近最少被访问的节点
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
// 移除最近最少被访问条件之一,通过覆盖此方法可实现不同策略的缓存
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
就是通过一些条件,判断是否移除最近最少被访问的节点。看到这里,大家应该知道上面两个方法的用途了。当我们基于 LinkedHashMap 实现缓存时,通过覆写removeEldestEntry
方法可以实现自定义策略的 LRU 缓存。比如我们可以根据节点数量判断是否移除最近最少被访问的节点,或者根据节点的存活时间判断是否移除该节点等。
现在使用LinkedHashMap来创建一个LRU:
import java.util.LinkedHashMap;
import java.util.Map;
public class SimpleCache<K,V> extends LinkedHashMap<K, V> {
//节点个数
private static final int MAX_NODE_NUM=100;
private int limit;
//无参构造函数
public SimpleCache() {
this(MAX_NODE_NUM);
}
//构造函数
public SimpleCache(int limit)
{
super(limit,0.75f,true);
this.limit=limit;
}
//添加节点:实际内部就是LinkedHashMap的put
public V save(K key,V val)
{
return put(key,val);
}
//获得节点:实际内部就是LinkedHashMap的get
public V getOne(K key)
{
return get(key);
}
//判断是否是包含了这个节点
public boolean contains(K key)
{
return containsKey(key);
}
//这个方法是必须要重写的,为了判断存在的键值对的个数是否大于限制
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size()>limit;
}
}
1.7 创建线程安全的LRU
ConcurrentHashMap
是线程安全的Map,我们可以利用它缓存 key,value形式的数据。ConcurrentLinkedQueue
是一个线程安全的基于链表的队列(先进先出),我们可以用它来维护 key 。每当我们put/get(缓存被使用)元素的时候,我们就将这个元素对应的 key 存放在队列尾部,这样就能保证队列头部的元素是最近最少使用的。当我们的缓存容量不够的时候,我们直接移除队列头部对应的key以及这个key对应的缓存即可!另外,我们用到了ReadWriteLock
(读写锁)来保证线程安全。
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
//创建线程安全的
public class MyLruCache<K,V> {
//最大容量
private final int maxCapacity;
//缓存
private ConcurrentHashMap<K,V> cacheMap;
//双向队列
private ConcurrentLinkedDeque<K> keys;
private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();
private Lock writeLock=readWriteLock.writeLock();
private Lock readLock=readWriteLock.readLock();
public MyLruCache(int maxCapacity) {
if(maxCapacity<0)
{
throw new IllegalArgumentException("Illegal");
}
this.maxCapacity = maxCapacity;
cacheMap=new ConcurrentHashMap<>(maxCapacity);
keys=new ConcurrentLinkedDeque<>();
}
public V put(K key,V value)
{
writeLock.lock();
try{
//1.key是否存在当前缓存中
if(cacheMap.containsKey(key))
{
moveToTailOfQueue(key);
cacheMap.put(key,value);
return value;
}
//2.是否超出缓存容量,超出的话移除队列头
if(cacheMap.size()==maxCapacity)
{
System.out.println("超出缓存");
removeOldestKey();
}
//3.如果不在缓存中,加入
keys.add(key);
cacheMap.put(key,value);
return value;
}finally {
writeLock.unlock();
}
}
public V get(K key)
{
//加读锁
readLock.lock();
try{
//如果缓存中有key,就将其keys放在后面
if(cacheMap.containsKey(key))
{
moveToTailOfQueue(key);
return cacheMap.get(key);
}
return null;
}finally {
readLock.unlock();
}
}
public V remove(K key)
{
//加写锁
writeLock.lock();
try{
//如果缓存包含,删除
if(cacheMap.containsKey(key))
{
keys.remove(key);
return cacheMap.remove(key);
}
return null;
}finally {
writeLock.unlock();
}
}
//当缓存容量满的时候,移除队列头部以及对应的缓存
private void removeOldestKey() {
K oldest=keys.poll();
if(oldest!=null)
{
cacheMap.remove(oldest);
}
}
//将元素添加到队列的尾部(put/get时候执行)
private void moveToTailOfQueue(K key) {
keys.remove(key);
keys.add(key);
}
}