Java和Android的LRU缓存及实现原理.docx
《Java和Android的LRU缓存及实现原理.docx》由会员分享,可在线阅读,更多相关《Java和Android的LRU缓存及实现原理.docx(19页珍藏版)》请在冰豆网上搜索。
![Java和Android的LRU缓存及实现原理.docx](https://file1.bdocx.com/fileroot1/2023-2/21/1675b143-337c-4a13-b57d-99e95f6b6bcf/1675b143-337c-4a13-b57d-99e95f6b6bcf1.gif)
Java和Android的LRU缓存及实现原理
一、概述
Android提供了LRUCache类,可以方便的使用它来实现LRU算法的缓存。
Java提供了LinkedHashMap,可以用该类很方便的实现LRU算法,Java的LRULinkedHashMap就是直接继承了LinkedHashMap,进行了极少的改动后就可以实现LRU算法。
二、Java的LRU算法
Java的LRU算法的基础是LinkedHashMap,LinkedHashMap继承了HashMap,并且在HashMap的基础上进行了一定的改动,以实现LRU算法。
1、HashMap
首先需要说明的是,HashMap将每一个节点信息存储在Entry结构中。
Entry中存储了节点对应的key、value、hash信息,同时存储了当前节点的下一个节点的引用。
因此Entry是一个单向链表。
HashMap的存储结构是一个数组加单向链表的形式。
每一个key对应的hashCode,在HashMap的数组中都可以找到一个位置;而如果多个key对应了相同的hashCode,那么他们在数组中对应在相同的位置上,这时,HashMap将把对应的信息放到Entry中,并使用链表连接这些Entry。
staticclassEntryimplementsMap.Entry{
finalKkey;
Vvalue;
Entrynext;
inthash;
/**
*Createsnewentry.
*/
Entry(inth,Kk,Vv,Entryn){
value=v;
next=n;
key=k;
hash=h;
}
publicfinalKgetKey(){
returnkey;
}
publicfinalVgetValue(){
returnvalue;
}
publicfinalVsetValue(VnewValue){
VoldValue=value;
value=newValue;
returnoldValue;
}
publicfinalbooleanequals(Objecto){
if(!
(oinstanceofMap.Entry))
returnfalse;
Map.Entrye=(Map.Entry)o;
Objectk1=getKey();
Objectk2=e.getKey();
if(k1==k2||(k1!
=null&&k1.equals(k2))){
Objectv1=getValue();
Objectv2=e.getValue();
if(v1==v2||(v1!
=null&&v1.equals(v2)))
returntrue;
}
returnfalse;
}
publicfinalinthashCode(){
returnObjects.hashCode(getKey())^Objects.hashCode(getValue());
}
publicfinalStringtoString(){
returngetKey()+"="+getValue();
}
/**
*Thismethodisinvokedwheneverthevalueinanentryis
*overwrittenbyaninvocationofput(k,v)forakeykthat'salready
*intheHashMap.
*/
voidrecordAccess(HashMapm){
}
/**
*Thismethodisinvokedwhenevertheentryis
*removedfromthetable.
*/
voidrecordRemoval(HashMapm){
}
}
下面贴一下HashMap的put方法的代码,并进行分析
publicVput(Kkey,Vvalue){
if(table==EMPTY_TABLE){
inflateTable(threshold);
}
if(key==null)
returnputForNullKey(value);
//以上信息不关心,下面是正常的插入逻辑。
//首先计算hashCode
inthash=hash(key);
//通过计算得到的hashCode,计算出hashCode在数组中的位置
inti=indexFor(hash,table.length);
//for循环,找到在HashMap中是否存在一个节点,对应的key与传入的key完全一致。
如果存在,说明用户想要替换该key对应的value值,因此直接替换value即可返回。
for(Entrye=table[i];e!
=null;e=e.next){
Objectk;
if(e.hash==hash&&((k=e.key)==key||key.equals(k))){
VoldValue=e.value;
e.value=value;
e.recordAccess(this);
returnoldValue;
}
}
//逻辑执行到此处,说明HashMap中不存在完全一致的kye.调用addEntry,新建一个节点保存key、value信息,并增加到HashMap中
modCount++;
addEntry(hash,key,value,i);
returnnull;
}
在上面的代码中增加了一些注释,可以对整体有一个了解。
下面具体对一些值得分析的点进行说明。
<1> inti=indexFor(hash,table.length);
可以看一下源码:
staticintindexFor(inth,intlength){
//assertInteger.bitCount(length)==1:
"lengthmustbeanon-zeropowerof2";
returnh&(length-1);
}
为什么获得的hashCode(h)要和(length-1)进行按位与运算?
这是为了保证去除掉h的高位信息。
如果数组大小为8(1000),而计算出的h的值为10(1010),如果直接获取数组的index为10的数据,肯定会抛出数组超出界限异常。
所以使用按位与(0111&1010),成功清除掉高位信息,得到2(0010),表示对应数组中index为2的数据。
效果与取余相同,但是位运算的效率明显更高。
但是这样有一个问题,如果length为9,获取得length-1信息为8(1000),这样进行位运算,不但不能清除高位数据,得到的结果肯定不对。
所以数组的大小一定有什么特别的地方。
通过查看源码,可以发现,HashMap无时无刻不在保证对应的数组个数为2的n次方。
首先在put的时候,调用inflateTable方法。
重点在于roundUpToPowerOf2方法,虽然它的内容包含大量的位相关的运算和处理,没有看的很明白,但是注释已经明确了,会保证数组的个数为2的n次方。
privatevoidinflateTable(inttoSize){
//Findapowerof2>=toSize
intcapacity=roundUpToPowerOf2(toSize);
threshold=(int)Math.min(capacity*loadFactor,MAXIMUM_CAPACITY+1);
table=newEntry[capacity];
initHashSeedAsNeeded(capacity);
}
其次,在addEntry等其他位置,也会使用(2*table.length)、table.length<<1等方式,保证数组的个数为2的n次方。
<2> for(Entrye=table[i];e!
=null;e=e.next)
因为HashMap使用的是数组加链表的形式,所以通过hashCode获取到在数组中的位置后,得到的不是一个Entry,而是一个Entry的链表,一定要循环链表,获取key对应的value。
<3> addEntry(hash,key,value,i);
先判断数组个数是否超出阈值,如果超过,需要增加数组个数。
然后会新建一个Entry,并加到数组中。
/**
*Addsanewentrywiththespecifiedkey,valueandhashcodeto
*thespecifiedbucket.Itistheresponsibilityofthis
*methodtoresizethetableifappropriate.
*
*Subclassoverridesthistoalterthebehaviorofputmethod.
*/
voidaddEntry(inthash,Kkey,Vvalue,intbucketIndex){
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);
}
/**
*LikeaddEntryexceptthatthisversionisusedwhencreatingentries
*aspartofMapconstructionor"pseudo-construction"(cloning,
*deserialization).Thisversionneedn'tworryaboutresizingthetable.
*
*SubclassoverridesthistoalterthebehaviorofHashMap(Map),
*clone,andreadObject.
*/
voidcreateEntry(inthash,Kkey,Vvalue,intbucketIndex){
Entrye=table[bucketIndex];
table[bucketIndex]=newEntry<>(hash,key,value,e);
size++;
}
2、LinkedHashMap
LinkedHashMap在HashMap的基础上,进行了修改。
首先将Entry由单向链表改成双向链表。
增加了before和after两个队Entry的引用。
privatestaticclassEntryextendsHashMap.Entry{
//Thesefieldscomprisethedoublylinkedlistusedforiteration.
Entrybefore,after;
Entry(inthash,Kkey,Vvalue,HashMap.Entrynext){
super(hash,key,value,next);
}
/**
*Removesthisentryfromthelinkedlist.
*/
privatevoidremove(){
before.after=after;
after.before=before;
}
/**
*Insertsthisentrybeforethespecifiedexistingentryinthelist.
*/
privatevoidaddBefore(EntryexistingEntry){
after=existingEntry;
before=existingEntry.before;
before.after=this;
after.before=this;
}
/**
*Thismethodisinvokedbythesuperclasswheneverthevalue
*ofapre-existingentryisreadbyMap.getormodifiedbyMap.set.
*IftheenclosingMapisaccess-ordered,itmovestheentry
*totheendofthelist;otherwise,itdoesnothing.
*/
voidrecordAccess(HashMapm){
LinkedHashMaplm=(LinkedHashMap)m;
if(lm.accessOrder){
lm.modCount++;
remove();
addBefore(lm.header);
}
}
voidrecordRemoval(HashMapm){
remove();
}
}
同时,LinkedHashMap提供了一个对Entry的引用header(privatetransientEntryheader)。
header的作用就是永远只是HashMap中所有成员的头(header.after)和尾(header.before)。
这样把HashMap本身的数组加链表的格式进行了修改。
在LinkedHashMap中,即保留了HashMap的数组加链表的数据保存格式,同时增加了一套header作为开始标记的双向链表(我们暂且称之为header的双向链表)。
LinkedHashMap就是通过header的双向链表来实现LRU算法的。
header.after永远指向最近最不常使用的那个节点,删除的话,就是删除这个header.after对应的节点。
相对的,header.before指向的就是刚刚使用过的那个节点。
LinkedHashMap并没有提供put方法,但是LinkedHashMap重写了addEntry和createEntry方法,如下:
/**
*Thisoverridealtersbehaviorofsuperclassputmethod.Itcausesnewly
*allocatedentrytogetinsertedattheendofthelinkedlistand
*removestheeldestentryifappropriate.
*/
voidaddEntry(inthash,Kkey,Vvalue,intbucketIndex){
super.addEntry(hash,key,value,bucketIndex);
//Removeeldestentryifinstructed
Entryeldest=header.after;
if(removeEldestEntry(eldest)){
removeEntryForKey(eldest.key);
}
}
/**
*ThisoverridediffersfromaddEntryinthatitdoesn'tresizethe
*tableorremovetheeldestentry.
*/
voidcreateEntry(inthash,Kkey,Vvalue,intbucketIndex){
HashMap.Entryold=table[bucketIndex];
Entrye=newEntry<>(hash,key,value,old);
table[bucketIndex]=e;
e.addBefore(header);
size++;
}
HashMap的put方法,调用了addEntry方法;HashMap的addEntry方法又调用了createEntry方法。
因此可以把上面的两个方法和HashMap中的内容放到一起,方便分析,形成如下方法:
voidaddEntry(inthash,Kkey,Vvalue,intbucketIndex){
if((size>=threshold)&&(null!
=table[bucketIndex])){
resize(2*table.length);
hash=(null!
=key)?
hash(key):
0;
bucketIndex=indexFor(hash,table.length);
}
HashMap.Entryold=table[bucketIndex];
Entrye=newEntry<>(hash,key,value,old);
table[bucketIndex]=e;
e.addBefore(header);
size++;
//Removeeldestentryifinstructed
Entryeldest=header.after;
if(removeEldestEntry(eldest)){
removeEntryForKey(eldest.key);
}
}
同样,先判断是否超出阈值,超出则增加数组的个数。
然后创建Entry对象,并加入到HashMap对应的数组和链表中。
与HashMap不同的是LinkedHashMap增加了e.addBefore(header);和removeEntryForKey(eldest.key);这样两个操作。
首先分析一下e.addBefore(header)。
其中e是LinkedHashMap.Entry对象,addBefore代码如下,作用就是讲header与当前对象相关联,使当前对象增加到header的双向链表的尾部(header.before):
privatevoidaddBefore(EntryexistingEntry){
after=existingEntry;
before=existingEntry.before;
before.after=this;
after.before=this;
}
其次是另一个重点,代码如下:
//Removeeldestentryifinstructed
Entryeldest=header.after;
if(removeEldestEntry(eldest)){
removeEntryForKey(eldest.key);
}
其中,removeEldestEntry判断是否需要删除最近最不常使用的那个节点。
LinkedHashMap中的removeEldestEntry(eldest)方法永远返回false,如果我们要实现LRU算法,就需要重写这个方法,判断在什么情况下,删除最近最不常使用的节点。
removeEntryForKey的作用就是将key对应的节点在HashMap的数组加链表结构中删除,源码如下:
finalEntryremoveEntryForKey(Objectkey){
if(size==0){
returnnull;
}
inthash=(key==null)?
0:
hash(key);
inti=indexFor(hash,table.length);
Entryprev=table[i];
Entrye=prev;
while(e!
=null){
Entrynext=e.next;
Objectk;
if(e.hash==hash&&
((k=e.key)==key||(key!
=null&&key.equals(k)))){
modCount++;
size--;
if(prev==e)
table[i]=next;
else
prev.next=next;
e.recordRemoval(this);
returne;
}
prev=e;
e=next;
}
returne;
}
removeEntryForKey是HashMap的方法,对LinkedHashMap中header的双向链表无能为力,而LinkedHashMap又没有重写这个方法,那header的双向链表要如何处理呢。
仔细看一下代码,可以看到在成功删除了HashMap中的节点后,调用了e.recordRemoval(this);方法。
这个方法在HashMap中为空,LinkedHashMap的Entry则实现了这个方法。
其中remove()方法中的两行代码为双向链表中删除当前节点的标准代码,不解释。
/**
*Removesthisentryfromthelinkedlist.
*/
privatevoidremove(){
before.after=after;
after.before=before;
}voidrecordRemoval(HashMapm){
remove();
}
以上,LinkedHashMap增加节点的代码分析完毕,可以看到完美的将新增的节点放在了header双向链表的末尾。
但是,这样显然是