hashmap是单向链表吗_LRU(Least Recent Used) java 实现为这么采用HashMap+双向链表
他采用HashMap+双向链表实现LRU(淘汰掉最不经常使用的)。先来将原文简单引用介绍下,以免原作者删除。
很久前参加过今日头条的面试,遇到一个题,目前半部分是如何实现 LRU,后半部分是 Redis 中如何实现 LRU。
我的第一反应是操作系统课程里学过,应该是内存不够的场景下,淘汰旧内容的策略。LRU ... Least Recent Used,淘汰掉最不经常使用的。可以稍微多补充两句,因为计算机体系结构中,最大的最可靠的存储是硬盘,它容量很大,并且内容可以固化,但是访问速度很慢,所以需要把使用的内容载入内存中;内存速度很快,但是容量有限,并且断电后内容会丢失,并且为了进一步提升性能,还有CPU内部的 L1 Cache,L2 Cache等概念。因为速度越快的地方,它的单位成本越高,容量越小,新的内容不断被载入,旧的内容肯定要被淘汰,所以就有这样的使用背景。
LRU原理
在一般标准的操作系统教材里,会用下面的方式来演示 LRU 原理,假设内存只能容纳3个页大小,按照 7 0 1 2 0 3 0 4 的次序访问页。假设内存按照栈的方式来描述访问时间,在上面的,是最近访问的,在下面的是,最远时间访问的,LRU就是这样工作的。
但是如果让我们自己设计一个基于 LRU 的缓存,这样设计可能问题很多,这段内存按照访问时间进行了排序,会有大量的内存拷贝操作,所以性能肯定是不能接受的。
那么如何设计一个LRU缓存,使得放入和移除都是 O(1) 的?
我们需要把访问次序维护起来,但是不能通过内存中的真实排序来反应,有一种方案就是使用HashMap+双向链表。
基于 HashMap 和 双向链表实现 LRU 的
整体的设计思路是,可以使用 HashMap key存储双向链表的数值,而 HashMap 的 Value 指向双向链表实现的 LRU 的 Node 节点,如图所示。(key指向Node节点,value指向数值也可以)
LRU中数据的存储和对使用时间新旧的维护是由 双向链表 实现的。(
在链表头的是最新使用的。
在尾部的是最旧的。也是下次要清除的。
如果加入的值是链表内存在的则要移动到头部。)
HashMap是来配合双向链表,用于减少时间复杂度的。它是可以快速的(O(1)的时间)定位,链表中某个值是否存在。(要不然需要遍历双向链表,时间复杂度为O(n) n为链表长度),定位到某个值存在后能马上获得他的node节点,因为是双向链表,直接用此节点的父节点,指向此节点的子节点。在将此节点放到头部就可以了。免除了遍历查找。
完整基于 Java 的代码参考如下
class DLinkedNode {
String key;
int value;
DLinkedNode pre;
DLinkedNode post;
}
LRU Cache
public class LRUCache {
private Hashtable
cache = new Hashtable();
private int count;
private int capacity;
private DLinkedNode head, tail;
public LRUCache(int capacity) {
this.count = 0;
this.capacity = capacity;
head = new DLinkedNode();
head.pre = null;
tail = new DLinkedNode();
tail.post = null;
head.post = tail;
tail.pre = head;
}
public int get(String key) {
DLinkedNode node = cache.get(key);
if(node == null){
return -1; // should raise exception here.
}
// move the accessed node to the head;
this.moveToHead(node);
return node.value;
}
public void set(String key, int value) {
DLinkedNode node = cache.get(key);
if(node == null){
DLinkedNode newNode = new DLinkedNode();
newNode.key = key;
newNode.value = value;
this.cache.put(key, newNode);
this.addNode(newNode);
++count;
if(count > capacity){
// pop the tail
DLinkedNode tail = this.popTail();
this.cache.remove(tail.key);
--count;
}
}else{
// update the value.
node.value = value;
this.moveToHead(node);
}
}
/**
* Always add the new node right after head;
*/
private void addNode(DLinkedNode node){
node.pre = head;
node.post = head.post;
head.post.pre = node;
head.post = node;
}
/**
* Remove an existing node from the linked list.
*/
private void removeNode(DLinkedNode node){
DLinkedNode pre = node.pre;
DLinkedNode post = node.post;
pre.post = post;
post.pre = pre;
}
/**
* Move certain node in between to the head.
*/
private void moveToHead(DLinkedNode node){
this.removeNode(node);
this.addNode(node);
}
// pop the current tail.
private DLinkedNode popTail(){
DLinkedNode res = tail.pre;
this.removeNode(res);
return res;
}
}
其实在上面我已经对原文做了补充了,解释了HashMap 和双向链表在此各自扮演的角色。下面在详细说下为什么用这连个数据结构的组合。这也是我在这篇文章后面的评论
1)首先我想的是用队列不行吗?
不行队列只能做到先进先出,但是重复用到中间的数据时无法把中间的数据移动到顶端。
2)就用单链表不行吗?
单链表能实现新来的放头部,最久不用的在尾部删除。但删除的时候需要遍历到尾部,因为单链表只有头指针。在用到已经用到过的数据时,还要遍历整合链表,来确定是否用过,然后再遍历到响应位置来剔除的节点,并重新放在头部。这效率可想而知。
这时hashmap的作用就出来了 他可以在单位1的时间判断value的值是否存在,key直接存储节点对象,能直接定位删除对应的节点(将比节点的父节点指向此节点的子节点)。
要通过一个节点直接获得父节点的话,通过单链表是不行的。
这时双向链表的作用也提现出来了。能直接定位到父节点。 这效率就很高了。而且由于双向链表有尾指针,所以剔除最后的尾节点也十分方便,快捷。
然后在补充原文作者在文章中所说的Redis的LRU实现
Redis的LRU实现
如果按照HashMap和双向链表实现,需要额外的存储存放 next 和 prev 指针,牺牲比较大的存储空间,显然是不划算的。所以Redis采用了一个近似的做法,就是随机取出若干个key,然后按照访问时间排序后,淘汰掉最不经常使用的,具体分析如下:
为了支持LRU,Redis 2.8.19中使用了一个全局的LRU时钟,server.lruclock,定义如下,
#define REDIS_LRU_BITS 24
unsigned lruclock:REDIS_LRU_BITS; /* Clock for LRU eviction */
默认的LRU时钟的分辨率是1秒,可以通过改变REDIS_LRU_CLOCK_RESOLUTION宏的值来改变,Redis会在serverCron()中调用updateLRUClock定期的更新LRU时钟,更新的频率和hz参数有关,默认为100ms一次,如下,
#define REDIS_LRU_CLOCK_MAX ((1<lru */
#define REDIS_LRU_CLOCK_RESOLUTION 1 /* LRU clock resolution in seconds */
void updateLRUClock(void) {
server.lruclock = (server.unixtime / REDIS_LRU_CLOCK_RESOLUTION) &
REDIS_LRU_CLOCK_MAX;
}
server.unixtime是系统当前的unix时间戳,当 lruclock 的值超出REDIS_LRU_CLOCK_MAX时,会从头开始计算,所以在计算一个key的最长没有访问时间时,可能key本身保存的lru访问时间会比当前的lrulock还要大,这个时候需要计算额外时间,如下,
/* Given an object returns the min number of seconds the object was never
* requested, using an approximated LRU algorithm. */
unsigned long estimateObjectIdleTime(robj *o) {
if (server.lruclock >= o->lru) {
return (server.lruclock - o->lru) * REDIS_LRU_CLOCK_RESOLUTION;
} else {
return ((REDIS_LRU_CLOCK_MAX - o->lru) + server.lruclock) *
REDIS_LRU_CLOCK_RESOLUTION;
}
}
Redis支持和LRU相关淘汰策略包括,
volatile-lru 设置了过期时间的key参与近似的lru淘汰策略
allkeys-lru 所有的key均参与近似的lru淘汰策略
当进行LRU淘汰时,Redis按如下方式进行的,
......
/* volatile-lru and allkeys-lru policy */
else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
{
for (k = 0; k < server.maxmemory_samples; k++) {
sds thiskey;
long thisval;
robj *o;
de = dictGetRandomKey(dict);
thiskey = dictGetKey(de);
/* When policy is volatile-lru we need an additional lookup
* to locate the real key, as dict is set to db->expires. */
if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
de = dictFind(db->dict, thiskey);
o = dictGetVal(de);
thisval = estimateObjectIdleTime(o);
/* Higher idle time is better candidate for deletion */
if (bestkey == NULL || thisval > bestval) {
bestkey = thiskey;
bestval = thisval;
}
}
}
......
Redis会基于server.maxmemory_samples配置选取固定数目的key,然后比较它们的lru访问时间,然后淘汰最近最久没有访问的key,maxmemory_samples的值越大,Redis的近似LRU算法就越接近于严格LRU算法,但是相应消耗也变高,对性能有一定影响,样本值默认为5。
LRU 的Java实现,光看代码的话还可以参考这篇文章:java LRU算法介绍与用法示例
hashmap是单向链表吗_LRU(Least Recent Used) java 实现为这么采用HashMap+双向链表相关推荐
- hashmap是单向链表吗_HashMap源码大剖析
本文目录哈希表的由来散列技术Map家族子类比较 HashMap与HashTable的区别? ConcurrentHashMap和Hashtable的区别? 同步集合与并发集合? HashMap存储结构 ...
- [C语言] 单向链表的构建以及翻转算法_图文详解(附双向链表构建代码)
[C语言]单向链表的构建以及翻转算法 一.基本概念 单向链表的链接方向是单向的,其中每个结点都有指针成员变量指向链表中的下一个结点,访问链表时要从头节点(带头节点的链表)或存储首个数据的节点(不带头节 ...
- java三位整数倒序相加_用单向链表实现两数倒序相加(java实现)
很久没做算法题了,准备重操旧业,于是刷了一波LeetCode,看到一个比较经典的链表算法题,分享出来. 题目 给定两个非空链表来表示两个非负整数.位数按照逆序方式存储,它们的每个节点只存储单个数字.将 ...
- 单向链表与双向链表区别
单向链表: 由两部分组成:数据域和指针域,每个结点都有一个指针,每个节点指针的指向都是指向自身结点的下一个结点,最后一个结点的head指向为null,对单链表的操作只能从一端开始,如果需要查找链表中的 ...
- LRU(Least Recent Used) java实现——为什么采用HashMap+双向链表
在知乎上看到一篇文章 : LRU原理和Redis实现--一个今日头条的面试题 他采用HashMap+双向链表实现LRU(淘汰掉最不经常使用的).先来将原文简单引用介绍下,以免原作者删除. 很久前参加过 ...
- Java 单向链表和单向循环链表的代码实现
这个链表,以前上学的时候,学c语言,还是数据结构的时候,学过.也许也实现过吧.下面我就简单记录下这个链表的实现. 单向链表跟单向循环链表的差别就是:单向链表是有结束位的,指向null的时候,就到结尾了 ...
- 二维指针删除单向链表
Linus slashdot: https://meta.slashdot.org/story/12/10/11/0030249 原文: https://coolshell.cn/article ...
- 【C++】【三】单向链表
// 单向链表.cpp : 此文件包含 "main" 函数.程序执行将在此处开始并结束. //#include <iostream> #include<stdli ...
- 基础数据结构【二】————动态数组,单向链表及链表的反转
DEMO1: 动态分配变量(链表,而静态数组是线性表,意味着动态数组访问和遍历复杂度为O(n),而插入和删除复杂度为O(1),而静态数组线性表则完全相反) int* intptr = new ...
最新文章
- java培训:Java的十大算法
- 简单介绍nginx 变量使用
- Metasploit reload命令使用技巧
- jq修改iframe html代码,使用jQuery替换iframe的所有内容(包括doctype和html标签)
- Optimize Search Results
- POJ 1655 Balancing Act (树的重心)
- C语言逆序字符串(递归实现)
- 你的简历已经被机器人筛选了
- python常用字符串_Python中最常用的字符串方法!
- python简明教程_05
- Vue-组件自定义事件-绑定-解绑
- 【鸡汤】过往不恋,未来不迎,当下不杂
- 计算机制图大赛,制图大赛简介
- P2433 【深基1-2】小学数学 N 合一
- 《Metasploit 魔鬼训练营》03 情报搜集技术
- 如何解决audiodg占用内存高(停止与重启audiodg服务)
- 穷举法(枚举法)实例解析
- 鸿蒙对比ios流畅,鸿蒙OS 2.0对比iOS 14:苹果流畅度完败?
- 关于Docker以及安装方法
- [翻译完成] 树莓派性能测试
热门文章
- UI设计中面性图标设计总结
- canvas教程6-绘制圆弧
- 异常:java.lang.ArithmeticException
- 前端页面嵌入二维码,微信扫出现请点击右上角,选择在浏览器中打开的解决方法
- CDA I级学习 - 漏斗模型
- 苹果 WWDC21 发布会全汇总,iOS 15更个性化,全家桶协作更有生产力
- 蜡笔小新钢达姆机器人_蜡笔小新作文500字_小学四年级作文 - 作文库
- photoshop中如何在6寸相纸上打印1寸照片10张2X5模式(自动填充模式)
- 通过Mixamo生成人物动画并导入Unity实现资源可用的方法
- gb2312的6763个汉字