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(最近最少使用)缓存的更多相关文章

  1. java 自定义 LRU(最近最少使用)策略 实现 缓存机制

    1. java提供了一个简单的方式实现LRU:  LinkedHashMap   2. 自定义实现 LRU至少需要两个主要操作: 添加(add)和搜索(search) public class LRU ...

  2. cache4j轻量级java内存缓存框架,实现FIFO、LRU、TwoQueues缓存模型

    简介 cache4j是一款轻量级java内存缓存框架,实现FIFO.LRU.TwoQueues缓存模型,使用非常方便. cache4j为java开发者提供一种更加轻便的内存缓存方案,杀鸡焉用EhCac ...

  3. java之hibernate之hibernate缓存

    这篇主要讲 hibernate缓存 1.缓存的作用是为了提高效率 2.Hibernate的开发效率比较高,但是执行效率相对较低. 3.Hibernate提供了缓存来提高效率.hibernate缓存分为 ...

  4. LinkedList实现基于LRU算法的缓存

    LinkedList实现基于LRU算法的缓存 2015年08月07日 18:18:45 秦江波 阅读数 2068 文章标签: java算法linkedlist缓存LRU更多 分类专栏: Java   ...

  5. Java高并发--CPU多级缓存与Java内存模型

    Java高并发--CPU多级缓存与Java内存模型 主要是学习慕课网实战视频<Java并发编程入门与高并发面试>的笔记 CPU多级缓存 为什么需要CPU缓存:CPU的频率太快,以至于主存跟 ...

  6. Java实现一个简单的缓存方法

    缓存是在web开发中经常用到的,将程序经常使用到或调用到的对象存在内存中,或者是耗时较长但又不具有实时性的查询数据放入内存中,在一定程度上可以提高性能和效率.下面我实现了一个简单的缓存,步骤如下. 创 ...

  7. Java生鲜电商平台-缓存架构实战

    Java生鲜电商平台-缓存架构实战 说明:在Java生鲜电商中,缓存起到了非常重要的作用,目前整个项目中才用的是redis做分布式缓存. 缓存集群 缓存集群存在的问题 1.热key 缓存集群中的某个k ...

  8. java 手写 jvm高性能缓存

    java 手写 jvm高性能缓存,键值对存储,队列存储,存储超时设置 缓存接口 package com.ws.commons.cache; import java.util.function.Func ...

  9. 使用linkedhashmap实现LRU(最近最少使用缓存算法)

    import java.util.LinkedHashMap; import java.util.Map; public class LRUCache<K, V> extends Link ...

随机推荐

  1. PTA 朋友圈【并查集的合并问题】

    一开始,考虑的是每次就是把第一个作为祖先,这样很明显是错误的,比如 7 4 3 1 2 3 2 4 2 3 5 6 7 1 6 所以这正是更好地体现对于集合的代表.只有把所有的元素合并一下,然后选一个 ...

  2. C#读取大文件

    有些时候需要读取文件,小文件的时候效率的影响可以忽略,但是当文件上M,上G的时候,这个时候,效率问题就非常重要了,下面将对一个3G的文件,用C#的方式读取,对比效率的影响. 1. FileStream ...

  3. 调试的时候禁止chrome缓存图片

    https://blog.csdn.net/yiifaa/article/details/54290047 https://blog.csdn.net/xinghuo0007/article/deta ...

  4. MySQL varchar 最大长度,text 类型占用空间剖析

    MySQL 表中行的最大大小为 65,534(实际行存储从第二个字节开始)字节.每个 BLOB 和 TEXT 列只占其中的 5 至 9 个字节. 那么来验证下 varchar 类型的实际最大长度: 测 ...

  5. selenium之webdriverAPI接口详解

    1. 浏览器操作 driver.maximize_window() #最大化窗口driver.execute_script('window.scrollTo(0,0);') #滚动窗口到最上面driv ...

  6. Hdu 4725 The Shortest Path in Nya Graph (spfa)

    题目链接: Hdu 4725 The Shortest Path in Nya Graph 题目描述: 有n个点,m条边,每经过路i需要wi元.并且每一个点都有自己所在的层.一个点都乡里的层需要花费c ...

  7. Educational Codeforces Round 46 (Rated for Div. 2) B. Light It Up

    Bryce1010模板 http://codeforces.com/problemset/problem/1000/B 思路:先用两个数组sumon[]和sumoff[]将亮着的灯和灭的灯累计一下. ...

  8. 1-8继承extends

    什么是继承? 继承是面向对象三大特征之一.java中的继承描述的是两个类之间的关系,被继承的类称为父类,继承的类称为子类,使用extends关键字来表示.在java语言里面只支持单继承,即一个类只能有 ...

  9. Myisamchk使用

    Myisam损坏的情况: . 服务器突然断电导致数据文件损坏;强制关机,没有先关闭mysql 服务;mysqld 进程在写表时被杀掉.因为此时mysql可能正在刷新索引. . 磁盘损坏. . 服务器死 ...

  10. 2. UITest相关APIs

    1. XCUIApplication 这是你正在测试的应用的代理.它能让你启动应用,这样你就能执行测试了.它每次都会新起一个进程,这会多花一些时间,但是能保证测试应用时的状态是干净的,这样你需要处理的 ...