Java implements LRU (least recently used) cache

2. Package com.jd.test;
4. Import java.io.Serializable;
6. Import Java.util.LinkedHashMap;
8. Import Java.util.concurrent.locks.Lock;
10. Import Java.util.concurrent.locks.ReentrantLock;
12. /**
14. * Cache Class (least recently unused)
16. *
18. * @author Liuzhenfeng
20. *
22. * @param <K,V>
24. */
26. Public class Lrucache<k, v> extends Linkedhashmap<k, v> implements Serializable {
28. /** 
30. * Cache Default Size
32. */
34. public static final int default_capasity = 20;
36. /** 
38. * Cache Actual Size
40. */
42. public static int cache_capasity = default_capasity;
44. /** 
46. * Thread Sync Lock
48. */
50. private static final lock lock = new Reentrantlock ();
52. Public LRUCache () {
54. super (default_capasity);
56. cache_capasity = default_capasity;
58. }
60. Public LRUCache (int size) {
62. super (size);
64. cache_capasity = size;
66. }
68. /* 
70. * Clear Cache
72. *
74. * @see Java.util.linkedhashmap#clear ()
76. */
78. @Override
80. public void Clear () {
82. try {
84. Lock.lock ();
86. super.clear ();
88. } finally {
90. Lock.unlock ();
92. }
94. }
96. /* 
98. * Determine if the object is included
100. *
102. * @see Java.util.linkedhashmap#containsvalue (java.lang.Object)
104. */
106. @Override
108. Public Boolean containsvalue (Object value) {
110. try {
112. Lock.lock ();
114. return super.containsvalue (value);
116. } finally {
118. Lock.unlock ();
120. }
122. }
124. /* 
126. * Querying objects from the cache
128. *
130. * @see Java.util.linkedhashmap#get (java.lang.Object)
132. */
134. @Override
136. Public V Get (Object key) {
138. try {
140. Lock.lock ();
142. return super.get (key);
144. } finally {
146. Lock.unlock ();
148. }
150. }
152. /* 
154. * Whether to delete the oldest unused cache object
156. *
158. * @see Java.util.linkedhashmap#removeeldestentry (java.util.Map.Entry)
160. */
162. @Override
164. protected Boolean removeeldestentry (java.util.map.entry<k, v> eldest) {
166. try {
168. Lock.lock ();
170. return this.size () > cache_capasity;
172. } finally {
174. Lock.unlock ();
176. }
178. }
180. /* 
182. * Determine if the key is included in the cache
184. *
186. * @see Java.util.hashmap#containskey (java.lang.Object)
188. */
190. @Override
192. Public Boolean containskey (Object key) {
194. try {
196. Lock.lock ();
198. return Super.containskey (key);
200. } finally {
202. Lock.unlock ();
204. }
206. }
208. /* 
210. * Determine if the cache is empty
212. *
214. * @see Java.util.hashmap#isempty ()
216. */
218. @Override
220. Public Boolean isEmpty () {
222. try {
224. Lock.lock ();
226. return super.isempty ();
228. } finally {
230. Lock.unlock ();
232. }
234. }
236. /* 
238. * Put in cache
240. *
242. * @see java.util.hashmap#put (java.lang.Object, Java.lang.Object)
244. */
246. @Override
248. Public V put (K key, V value) {
250. try {
252. Lock.lock ();
254. return super.put (key, value);
256. } finally {
258. Lock.unlock ();
260. }
262. }
264. /* 
266. * Removed from cache
268. *
270. * @see Java.util.hashmap#remove (java.lang.Object)
272. */
274. @Override
276. Public V Remove (Object key) {
278. try {
280. Lock.lock ();
282. return super.remove (key);
284. } finally {
286. Lock.unlock ();
288. }
290. }
292. /* 
294. * Cache Size
296. *
298. * @see Java.util.hashmap#size ()
300. */
302. @Override
304. public int size () {
306. try {
308. Lock.lock ();
310. return super.size ();
312. } finally {
314. Lock.unlock ();
316. }
318. }
320. }

The re-entry lock (Reentrantlock) is a recursive, non-blocking synchronization mechanism. It was previously thought to be a simple alternative to synchronized, and the implementation mechanism was not too far apart. But the recent practice has found a difference between them.

Here is the official note: a reentrant mutex lock lock, which has the same basic behavior and semantics as the implicit monitor lock accessed using the Synchronized method and the statement, but is more powerful. Reentrantlock will be owned by a thread that has recently successfully acquired a lock and has not released the lock. When the lock is not owned by another thread, the thread that called lock succeeds in acquiring the lock and returns. If the current thread already owns the lock, this method will return immediately. You can use the Isheldbycurrentthread () and Getholdcount () methods to check whether this condition occurs.

It provides the lock () method:
If the lock is not persisted by another thread, gets the lock and returns immediately, setting the locked hold count to 1.
If the current thread has already held the lock, the count will be added to 1, and the method returns immediately.
If the lock is persisted by another thread, the current thread is disabled for the purpose of thread scheduling, and the thread will remain dormant until the lock is acquired, at which time the lock hold count is set to 1.

Java implements LRU (least recently used) cache