码迷，mamicode.com
首页 > 编程语言 > 详细

Java实现LRU（最近最少使用）缓存

时间：2015-12-24 10:27:24      阅读：160      评论：0      收藏：0      [点我收藏+]

标签：

 

  1. package com.jd.test;  
  2. import java.io.Serializable;  
  3. import java.util.LinkedHashMap;  
  4. import java.util.concurrent.locks.Lock;  
  5. import java.util.concurrent.locks.ReentrantLock;  
  6. /** 
  7.  * 缓存类（最近最少未使用） 
  8.  *  
  9.  * @author liuzhenfeng 
  10.  *  
  11.  * @param <K,V> 
  12.  */  
  13. public class LRUCache<K, V> extends LinkedHashMap<K, V> implements Serializable {  
  14.     /** 
  15.      * 缓存默认大小 
  16.      */  
  17.     public static final int DEFAULT_CAPASITY = 20;  
  18.     /** 
  19.      * 缓存实际大小 
  20.      */  
  21.     public static int CACHE_CAPASITY = DEFAULT_CAPASITY;  
  22.     /** 
  23.      * 线程同步锁 
  24.      */  
  25.     private static final Lock lock = new ReentrantLock();  
  26.     public LRUCache() {  
  27.         super(DEFAULT_CAPASITY);  
  28.         CACHE_CAPASITY = DEFAULT_CAPASITY;  
  29.     }  
  30.     public LRUCache(int size) {  
  31.         super(size);  
  32.         CACHE_CAPASITY = size;  
  33.     }  
  34.     /* 
  35.      * 清空緩存 
  36.      *  
  37.      * @see java.util.LinkedHashMap#clear() 
  38.      */  
  39.     @Override  
  40.     public void clear() {  
  41.         try {  
  42.             lock.lock();  
  43.             super.clear();  
  44.         } finally {  
  45.             lock.unlock();  
  46.         }  
  47.     }  
  48.     /* 
  49.      * 判断是否包含该对象 
  50.      *  
  51.      * @see java.util.LinkedHashMap#containsValue(java.lang.Object) 
  52.      */  
  53.     @Override  
  54.     public boolean containsValue(Object value) {  
  55.         try {  
  56.             lock.lock();  
  57.             return super.containsValue(value);  
  58.         } finally {  
  59.             lock.unlock();  
  60.         }  
  61.     }  
  62.     /* 
  63.      * 从缓存中查询对象 
  64.      *  
  65.      * @see java.util.LinkedHashMap#get(java.lang.Object) 
  66.      */  
  67.     @Override  
  68.     public V get(Object key) {  
  69.         try {  
  70.             lock.lock();  
  71.             return super.get(key);  
  72.         } finally {  
  73.             lock.unlock();  
  74.         }  
  75.     }  
  76.     /* 
  77.      * 是否删除最早未使用缓存对象 
  78.      *  
  79.      * @see java.util.LinkedHashMap#removeEldestEntry(java.util.Map.Entry) 
  80.      */  
  81.     @Override  
  82.     protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {  
  83.         try {  
  84.             lock.lock();  
  85.             return this.size() > CACHE_CAPASITY;  
  86.         } finally {  
  87.             lock.unlock();  
  88.         }  
  89.     }  
  90.     /* 
  91.      * 判断缓存中是否包含该key 
  92.      *  
  93.      * @see java.util.HashMap#containsKey(java.lang.Object) 
  94.      */  
  95.     @Override  
  96.     public boolean containsKey(Object key) {  
  97.         try {  
  98.             lock.lock();  
  99.             return super.containsKey(key);  
  100.         } finally {  
  101.             lock.unlock();  
  102.         }  
  103.     }  
  104.     /* 
  105.      * 判断缓存是否为空 
  106.      *  
  107.      * @see java.util.HashMap#isEmpty() 
  108.      */  
  109.     @Override  
  110.     public boolean isEmpty() {  
  111.         try {  
  112.             lock.lock();  
  113.             return super.isEmpty();  
  114.         } finally {  
  115.             lock.unlock();  
  116.         }  
  117.     }  
  118.     /* 
  119.      * 放入缓存 
  120.      *  
  121.      * @see java.util.HashMap#put(java.lang.Object, java.lang.Object) 
  122.      */  
  123.     @Override  
  124.     public V put(K key, V value) {  
  125.         try {  
  126.             lock.lock();  
  127.             return super.put(key, value);  
  128.         } finally {  
  129.             lock.unlock();  
  130.         }  
  131.     }  
  132.     /* 
  133.      * 从缓存中删除 
  134.      *  
  135.      * @see java.util.HashMap#remove(java.lang.Object) 
  136.      */  
  137.     @Override  
  138.     public V remove(Object key) {  
  139.         try {  
  140.             lock.lock();  
  141.             return super.remove(key);  
  142.         } finally {  
  143.             lock.unlock();  
  144.         }  
  145.     }  
  146.     /* 
  147.      * 缓存大小 
  148.      *  
  149.      * @see java.util.HashMap#size() 
  150.      */  
  151.     @Override  
  152.     public int size() {  
  153.         try {  
  154.             lock.lock();  
  155.             return super.size();  
  156.         } finally {  
  157.             lock.unlock();  
  158.         }  
  159.     }  
  160. }  

 

 

 

 

重入锁（ReentrantLock）是一种递归无阻塞的同步机制。以前一直认为它是synchronized的简单替代，而且实现机制也不相差太远。不过最近实践过程中发现它们之间还是有着天壤之别。

以下是官方说明：一个可重入的互斥锁定 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁定相同的一些基本行为和语义，但功能更强大。ReentrantLock 将由最近成功获得锁定，并且还没有释放该锁定的线程所拥有。当锁定没有被另一个线程所拥有时，调用 lock 的线程将成功获取该锁定并返回。如果当前线程已经拥有该锁定，此方法将立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法来检查此情况是否发生。

它提供了lock()方法：
如果该锁定没有被另一个线程保持，则获取该锁定并立即返回，将锁定的保持计数设置为 1。
如果当前线程已经保持该锁定，则将保持计数加 1，并且该方法立即返回。
如果该锁定被另一个线程保持，则出于线程调度的目的，禁用当前线程，并且在获得锁定之前，该线程将一直处于休眠状态，此时锁定保持计数被设置为 1。

 

Java实现LRU（最近最少使用）缓存

标签：

原文地址：http://www.cnblogs.com/likeju/p/5072202.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！