Four types of references in Java-----

java Four kinds of references, soft and weak, used to the sceneTags: java reference weak soft virtual2016-05-11 22:59 1237 people read comments (0) favorite reports

1. Strong citation (Strongreference)

Strong references are the most commonly used references. If an object has a strong reference, the garbage collector will never recycle it. As follows:

1	Object O=new object (); Strong references

When there is not enough memory space, the Java virtual Machine prefers to throw a outofmemoryerror error, which causes the program to terminate abnormally, and does not rely on random recycling of strongly referenced objects to resolve out-of-memory issues. If not, use the following method to weaken the reference, as follows:

1	O=null; Help garbage collector Reclaim this object

Explicitly setting o to null, or exceeding the life cycle of an object, the GC considers that the object does not have a reference and can then reclaim the object. The exact time to collect this depends on the GC algorithm.

Example:

1 2 3 4

public void Test () { Object O=new object (); Omit other actions }

There is a strong reference inside a method that is stored in the stack, and the real reference content (Object) is stored in the heap. When this method runs and exits the method stack, references to references do not exist, and the object is recycled.

However, if this o is a global variable, you will need to assign NULL when you do not use this object, because a strong reference is not garbage collected.

Strong references have very important uses in practice, for example, a ArrayList implementation source code:

1 2 3 4 5 6 7 8

Private transient object[] elementdata; public void Clear () { modcount++; Let GC do it work for (int i = 0; i < size; i++) Elementdata[i] = null; size = 0; }

A private variable elementdata array is defined in the ArrayList class, and you can see that the contents of each array are assigned NULL when the calling method empties the array. Unlike Elementdata=null, strong references persist to avoid re-allocating memory when adding elements such as subsequent calls to add (). Using methods such as the clear () method to free memory is particularly useful for the type of reference that is stored in the array, which frees up memory in a timely manner.

2. Soft Reference (SoftReference)

If an object has only soft references, enough memory space is available, the garbage collector does not recycle it, and if the memory space is insufficient, the memory of those objects is reclaimed. The object can be used by the program as long as it is not reclaimed by the garbage collector. Soft references can be used to implement memory-sensitive caches.

1 2	String Str=new string ("abc"); Strong references softreference<string> softref=new softreference<string> (str); Soft references

When memory is low, it is equivalent to:

1 2 3 4

If (JVM. Insufficient memory ()) { str = NULL; Convert to Soft reference System.GC (); Garbage collector for Recycling }

Virtual references have important applications in practice, such as the browser's Back button. When you press back, will the page content that is displayed on the back of this fallback be re-requested or removed from the cache? This depends on the specific implementation strategy.

(1) If a Web page is recycled at the end of the browse, then pressing back to view the previously browsed page needs to be rebuilt

(2) If you store your browsed pages in memory, it can cause a lot of wasted memory and even memory overflow.

You can then use soft references

1 2 3 4 5 6 7 8

Browser prev = new Browser (); Get page to browse softreference sr = new SoftReference (prev); After browsing is complete, set to soft reference if (Sr.get ()!=null) { Rev = (Browser) sr.get (); Has not been recovered by the collector, directly obtained }else{ prev = new Browser (); Because of the memory crunch, the soft-referenced objects are recycled sr = new SoftReference (prev); Re-build }

This will be a good solution to the actual problem.

A soft reference can be used in conjunction with a reference queue (Referencequeue), and if the object referenced by the soft reference is reclaimed by the garbage collector, the Java Virtual machine will add the soft reference to the reference queue associated with it.

3. Weak references (WeakReference)

The difference between a weak reference and a soft reference is that an object with only a weak reference has a shorter life cycle. As the garbage collector thread scans the area of memory it governs, once an object with only a weak reference is found, its memory is reclaimed, regardless of whether the current memory space is sufficient or not. However, because the garbage collector is a low-priority thread, it is not necessarily quick to discover objects that have only weak references.

1 2 3

String Str=new string ("abc"); weakreference<string> abcweakref = new weakreference<string> (str); Str=null;

When the garbage collector is scanned for recycling, it is equivalent to:

?

1 2	str = NULL; System.GC ();

If this object is used occasionally and wants to be available at any time when it is used, but does not want to affect the garbage collection of this object, then you should use Weak Reference to remember this object.

The following code causes STR to become a strong reference again:

1	String ABC = abcweakref.get ();

A weak reference can be used in conjunction with a reference queue (Referencequeue), and if the object referenced by the weak reference is garbage collected, the Java virtual machine adds the weak reference to the reference queue associated with it.

When you want to refer to an object, but this object has its own life cycle, you do not want to intervene in the life cycle of this object, you are using weak references.

This reference does not have any additional impact on the object's garbage collection judgment.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21st 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

public class Referencetest { private static referencequeue<verybig> RQ = new referencequeue<verybig> (); public static void Checkqueue () { reference<? Extends verybig> ref = NULL; while (ref = Rq.poll ()) = null) { if (ref! = NULL) { System.out.println ("In Queue:" + ((verybigweakreference) (ref)). ID); } } } public static void Main (String args[]) { int size = 3; linkedlist<weakreference<verybig>> weaklist = new linkedlist<weakreference<verybig>> (); for (int i = 0; i < size; i++) { Weaklist.add (New Verybigweakreference (New Verybig ("Weak" + i), RQ)); System.out.println ("Just created weak:" + weaklist.getlast ()); } System.GC (); try {//under rest for a few minutes and let the garbage collection thread above run complete Thread.CurrentThread (). Sleep (6000); } catch (Interruptedexception e) { E.printstacktrace (); } Checkqueue (); } } Class Verybig { public String ID; Take up space for the thread to recycle Byte[] B = new byte[2 * 1024]; Public Verybig (String ID) { This.id = ID; } protected void Finalize () { System.out.println ("finalizing verybig" + ID); } } Class Verybigweakreference extends Weakreference<verybig> { public String ID; Public Verybigweakreference (Verybig big, referencequeue<verybig> RQ) { Super (big, RQ); This.id = big.id; } protected void Finalize () { System.out.println ("finalizing verybigweakreference" + ID); } }

The result of the final output is:

1 2 3 4 5 6 7 8 9

Just created weak: [email protected] Just created weak: [email protected] Just created weak: [email protected] Finalizing Verybig Weak 2 Finalizing Verybig Weak 1 Finalizing Verybig Weak 0 In Queue:weak 1 In Queue:weak 2 In Queue:weak 0

4. Virtual Reference (Phantomreference)

"Virtual Reference", as the name implies, is a dummy, unlike several other references, a virtual reference does not determine the object's life cycle. If an object holds only virtual references, it can be reclaimed by the garbage collector at any time, just as there are no references.

Virtual references are primarily used to track activities that objects are reclaimed by the garbage collector. One difference between a virtual reference and a soft reference and a weak reference is that the virtual reference must be used in conjunction with the reference queue (Referencequeue). When the garbage collector prepares to reclaim an object, if it finds that it has a virtual reference, it will add the virtual reference to the reference queue associated with it before reclaiming the object's memory.

5. Summary

The level of JAVA4 references is from highest to lowest:

Strong references > Soft references > Weak references > virtual references

Take a look at the differences between them in garbage collection:

When the garbage collector recycles, some objects are reclaimed and some are not recycled. The garbage collector marks the surviving object from the root object, and then reclaims some unreachable objects and some referenced objects, and if you are not familiar with this, refer to the following article:

Four types of references in Java-----