Idle to Nothing, with Java's soft reference to write a cottage cache

Idle to Nothing, with Java's soft reference to write a cottage cache Blog Category:

• Java Basics

It is well known that references in Java are divided into Strongreference, SoftReference, WeakReference, Phantomreference. These kinds of references have different uses of the scene, usually we use the most frequent is the strongreference, that is to say the form of such a reference:

Object obj = new Object ();

such a reference is called a strong reference, and if the object does not have a reference to it, and the surviving thread cannot access it (for a garbage island), then he is recycled, and if the object is pointed to by a strong reference and the memory is exhausted, the object is not reclaimed by the Oom garbage collector.

For SoftReference, it is less stringent for GC recycling, and if the current strongest reference to an object is a soft reference, and the JVM has sufficient memory, the garbage collector will not recycle the object. The GC reclaims the object pointed to by the soft reference only when the memory is tight, and from this we can see that the soft reference could be used to do some caching, better with the LRU strategy. Today I will write a play.

Java code

1. The code is as follows:

Java code

2. Package com.blackbeans.example;
6. Import java.lang.ref.Reference;
8. Import Java.lang.ref.ReferenceQueue;
10. Import java.lang.ref.SoftReference;
12. Import Java.util.HashMap;
16. /**
18. *
20. * @author Blackbeans
22. * @param <K>
24. * @param <T>
26. */
28. Public class Referencecache<k,t> {
34. private hashmap<k, innerreference<k,t>> cachedreference = new hashmap<k, innerreference<k,t  >> (1024);
36. Private final referencequeue<t> referencequeue;
40. Private final objectnotfoundhandler<k,t> Existshandler;
44. /** 
46. * Processors that are not in the default cache
48. * @author Blackbeans
50. *
52. * @param <K>
54. * @param <T>
56. */
58. private static class defaultobjectnotfoundhandler<k,t> implements Objectnotfoundhandler<k, t>
60. {
62. @Override
64. Public T queryandcached (K key) {
66. //TODO auto-generated method stub
68. return null;
70. }
74. }
78. /** 
80. * Processors that are not in the cache
82. * @author Blackbeans
84. *
86. * @param <K>
88. * @param <T>
90. */
92. public Static interface objectnotfoundhandler<k,t>
94. {
96. Public T queryandcached (K key);
100. }
106. private static class innerreference<k,t> extends softreference<t>{
108. Private final K key;
110. Public innerreference (K key,t reference,referencequeue<t> queue) {
112. super (Reference,queue);
114. This.key = key;
116. }
120. Public K GetKey ()
122. {
124. return This.key;
126. }
128. }
134. Public Referencecache (objectnotfoundhandler<k,t> handler)
136. {
138. this.referencequeue = new referencequeue<t> ();
140. This.existshandler = Handler = = null?  New Defaultobjectnotfoundhandler<k,t> (): handler;
142. }
148. Public Referencecache ()
150. {
152. This (null);
154. }
158. public void cachedreference (K key,t Reference)
160. {
162. /** 
164. * Clears objects that are soft-referenced and has been recycled reference
166. */
168. Cleanreference (key);
170. if (! This.cachedReference.containsKey (key))
172. {
174. this.cachedReference.put (Key, new Innerreference<k,t> (key,reference, this.referencequeue));
176. }
178. }
182. Public T getreference (K key) {
186. T obj = null;
190. if (This.cachedReference.containsKey (key)) {
192. obj = this.cachedReference.get (key). get ();
194. }
198. if (null = = obj)
200. {
202. /** 
204. * Soft references to objects are recycled and cached by the soft reference
206. */
208. obj = this.existsHandler.queryAndCached (key);
210. this.cachedreference (key, obj);
212. return obj;
214. }
216. return obj;
220. }
224. @SuppressWarnings ("unchecked")
226. private void Cleanreference (K key) {
228. //Priority check if key corresponds to soft-referenced object being recycled
230. if (this.cachedReference.containsKey (key)
232. && This.cachedReference.get (key). Get () = = null)
234. This.cachedReference.remove (key);

Java code

2. <span style="WHITE-SPACE:PRE;"  > </span>t obj = null;
4. //Remove the key if the soft-referenced object that corresponds to the current key is recycled
6. reference<?  extends t> reference = null;
8. While ((reference = This.referenceQueue.poll ()) = null)
10. {
12. obj = Reference.get ();
14. if (obj = = null)
16. {
18. This.cachedReference.remove (((innerreference<k, t>) reference). GetKey ());
20. }
22. }
24. }
30. public void Clearallobject ()
32. {
34. this.cachedReference.clear ();
36. System.GC ();
38. }
42. }

in the entire implementation by putting the object's reference into a key-> soft reference map I defined, and then each time I get the object from the cache, the key is used to query the map to get the soft reference of the object, and if it exists, it tries to get the object by soft reference, if it does not exist, The object that the soft reference points to is recycled, then we go back to call the built-in handler, regenerate an object, and cache the soft reference of the object.

In my implementation I provide the user with a processing handler when the object is recycled, trying to guide the user through this handler to reconstruct the object, the cache object, the flexibility is still very large.

The disadvantage is that if the soft-referenced cache is more perfect with the LRU policy, a processor for the LRU is provided for the user to customize the LRU policy. In fact, it is very simple to replace the HashMap with Linkedhashmap to implement the Removeeldest method, and call the custom LRU processor in the method is OK.

To reduce the overhead, I cleaned out the failed soft references every time the cache was made. Maybe someone will ask why is there a referencequeue? In fact, after the object referenced by the soft reference is recycled, imagine that the object soft reference is being recycled, but you have introduced another object softreference, take away one is not to leave another, so will not, soft reference object is recycled, The soft reference itself is added to this queue, waiting to be recycled. By facilitating this queue to get a soft reference to an out-of-date soft reference in the map.

At this point, the said also said, should not say also said, the end is very abrupt, please forgive me!

Reprint: http://blackbeans.iteye.com/blog/1039464

Idle to Nothing, with Java's soft reference to write a cottage cache