Java和Android的LRU缓存及实现原理.docx
《Java和Android的LRU缓存及实现原理.docx》由会员分享，可在线阅读，更多相关《Java和Android的LRU缓存及实现原理.docx（19页珍藏版）》请在冰豆网上搜索。
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双向链表的末尾。
但是，这样显然是
升级会员 