java缓存Word格式文档下载.docx
- 文档编号:20287790
- 上传时间:2023-01-21
- 格式:DOCX
- 页数:25
- 大小:25.19KB
java缓存Word格式文档下载.docx
《java缓存Word格式文档下载.docx》由会员分享,可在线阅读,更多相关《java缓存Word格式文档下载.docx(25页珍藏版)》请在冰豆网上搜索。
value=object;
publicbooleanisExpired(){
returnexpired;
publicvoidsetExpired(booleanb){
expired=b;
//测试类,
classTest{
publicstaticvoidmain(String[]args){
System.out.println(CacheManager.getSimpleFlag("
alksd"
));
//CacheManager.putCache("
abc"
newCache());
def"
ccc"
//CacheManager.clearOnly("
"
);
//Cachec=newCache();
//for(inti=0;
i<
10;
i++){
+i,c);
//}
aaaaaaaa"
c);
abchcy;
alskd"
cccccccc"
abcoqiwhcy"
//System.out.println("
删除前的大小:
+CacheManager.getCacheSize());
//CacheManager.getCacheAllkey();
//CacheManager.clearAll("
aaaa"
删除后的大小:
JAVA缓存-CacheManager类
publicclassCacheManager{
privatestaticHashMapcacheMap=newHashMap();
//单实例构造方法
privateCacheManager(){
//获取布尔值的缓存
publicstaticbooleangetSimpleFlag(Stringkey){
try{
return(Boolean)cacheMap.get(key);
}catch(NullPointerExceptione){
returnfalse;
publicstaticlonggetServerStartdt(Stringkey){
try{
return(Long)cacheMap.get(key);
}catch(Exceptionex){
return0;
//设置布尔值的缓存
publicsynchronizedstaticbooleansetSimpleFlag(Stringkey,booleanflag){
if(flag&
&
getSimpleFlag(key)){//假如为真不允许被覆盖
}else{
cacheMap.put(key,flag);
returntrue;
publicsynchronizedstaticbooleansetSimpleFlag(Stringkey,longserverbegrundt){
if(cacheMap.get(key)==null){
cacheMap.put(key,serverbegrundt);
//得到缓存。
同步静态方法
privatesynchronizedstaticCachegetCache(Stringkey){
return(Cache)cacheMap.get(key);
//判断是否存在一个缓存
privatesynchronizedstaticbooleanhasCache(Stringkey){
returncacheMap.containsKey(key);
}
//清除所有缓存
publicsynchronizedstaticvoidclearAll(){
cacheMap.clear();
//清除某一类特定缓存,通过遍历HASHMAP下的所有对象,来判断它的KEY与传入的TYPE是否匹配
publicsynchronizedstaticvoidclearAll(Stringtype){
Iteratori=cacheMap.entrySet().iterator();
Stringkey;
ArrayListarr=newArrayList();
while(i.hasNext()){
java.util.Map.Entryentry=(java.util.Map.Entry)i.next();
key=(String)entry.getKey();
if(key.startsWith(type)){//如果匹配则删除掉
arr.add(key);
for(intk=0;
k<
arr.size();
k++){
clearOnly(arr.get(k));
ex.printStackTrace();
//清除指定的缓存
publicsynchronizedstaticvoidclearOnly(Stringkey){
cacheMap.remove(key);
//载入缓存
publicsynchronizedstaticvoidputCache(Stringkey,Cacheobj){
cacheMap.put(key,obj);
//获取缓存信息
publicstaticCachegetCacheInfo(Stringkey){
if(hasCache(key)){
Cachecache=getCache(key);
if(cacheExpired(cache)){//调用判断是否终止方法
cache.setExpired(true);
returncache;
}else
returnnull;
//载入缓存信息
publicstaticvoidputCacheInfo(Stringkey,Cacheobj,longdt,booleanexpired){
Cachecache=newCache();
cache.setKey(key);
cache.setTimeOut(dt+System.currentTimeMillis());
//设置多久后更新缓存
cache.setValue(obj);
cache.setExpired(expired);
//缓存默认载入时,终止状态为FALSE
cacheMap.put(key,cache);
//重写载入缓存信息方法
publicstaticvoidputCacheInfo(Stringkey,Cacheobj,longdt){
cache.setTimeOut(dt+System.currentTimeMillis());
cache.setExpired(false);
cacheMap.put(key,cache);
//判断缓存是否终止
publicstaticbooleancacheExpired(Cachecache){
if(null==cache){//传入的缓存不存在
longnowDt=System.currentTimeMillis();
//系统当前的毫秒数
longcacheDt=cache.getTimeOut();
//缓存内的过期毫秒数
if(cacheDt<
=0||cacheDt>
nowDt){//过期时间小于等于零时,或者过期时间大于当前时间时,则为FALSE
}else{//大于过期时间即过期
//获取缓存中的大小
publicstaticintgetCacheSize(){
returncacheMap.size();
//获取指定的类型的大小
publicstaticintgetCacheSize(Stringtype){
intk=0;
if(key.indexOf(type)!
=-1){//如果匹配则删除掉
k++;
returnk;
//获取缓存对象中的所有键值名称
publicstaticArrayListgetCacheAllkey(){
ArrayLista=newArrayList();
a.add((String)entry.getKey());
}catch(Exceptionex){}finally{
returna;
//获取缓存对象中指定类型的键值名称
publicstaticArrayListgetCacheListkey(Stringtype){
=-1){
a.add(key);
2007-09-29
简单LRU算法实现缓存
最简单的LRU算法实现,就是利用jdk的LinkedHashMap,覆写其中的removeEldestEntry(Map.Entry)方法即可,如下所示:
java代码
1.import
java.util.ArrayList;
2.import
java.util.Collection;
3.import
java.util.LinkedHashMap;
4.import
java.util.concurrent.locks.Lock;
5.import
java.util.concurrent.locks.ReentrantLock;
6.import
java.util.Map;
7.
8.
9./**
10.
*
类说明:
利用LinkedHashMap实现简单的缓存,
必须实现removeEldestEntry方法,具体参见JDK文档
11.
12.
@author
dennis
13.
14.
@param
<
K>
15.
V>
16.
*/
17.public
class
LRULinkedHashMap<
K,
extends
LinkedHashMap<
{
18.
private
final
int
maxCapacity;
19.
20.
static
float
DEFAULT_LOAD_FACTOR
=
0.75f;
21.
22.
Lock
lock
new
ReentrantLock();
23.
24.
public
LRULinkedHashMap(int
maxCapacity)
25.
super(maxCapacity,
DEFAULT_LOAD_FACTOR,
true);
26.
this.maxCapacity
27.
}
28.
29.
@Override
30.
protected
boolean
removeEldestEntry(java.util.Map.Entry<
eldest)
31.
return
size()
>
32.
33.
34.
containsKey(Object
key)
35.
try
36.
lock.lock();
37.
super.containsKey(key);
38.
finally
39.
lock.unlock();
40.
41.
42.
43.
44.
45.
V
get(Object
46.
47.
48.
super.get(key);
49.
50.
51.
52.
53.
54.
55.
put(K
key,
value)
56.
57.
58.
super.put(key,
value);
59.
60.
61.
62.
63.
64.
65.
66.
67.
super.size();
68.
69.
70.
71.
72.
73.
void
clear()
74.
75.
76.
super.clear();
77.
78.
79.
80.
81.
82.
Collection<
Map.Entry<
getAll()
83.
84.
85.
ArrayList<
(super.entrySet());
86.
87.
88.
89.
90.}
91.
如果你去看LinkedHashMap的源码可知,LRU算法是通过双向链表来实现,当某个位置被命中,通过调整链表的指向将该位置调整到头位置,新加入的内容直接放在链表头,如此一来,最近被命中的内容就向链表头移动,需要替换时,链表最后的位置就是最近最少使用的位置。
LRU算法还可以通过计数来实现,缓存存储的位置附带一个计数器,当命中时将计数器加1,替换时就查找计数最小的位置并替换,结合访问时间戳来实现。
这种算法比较适合缓存数据量较小的场景,显然,遍历查找计数最小位置的时间复杂度为O(n)。
我实现了一个,结合了访问时间戳,当最小计数大于MINI_ACESS时,就移除最久没有被访问的项:
java.io.Serializable;
java.util.HashMap;
java.util.Iterator;
7.import
java.util.Set;
8.import
java.util.concurrent.atomic.AtomicInteger;
9.import
java.util.concurrent.atomic.AtomicLong;
10.import
11.import
13./**
当缓存数目不多时,才用缓存计数的传统LRU算法
17.
20.public
LRUCache<
implements
Serializable
DEFAULT_CAPACITY
100;
Map<
Valu
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- java 缓存