Go Strong references for Java, weak references, soft references, virtual references

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:

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:

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:

 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:

 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.

String str=New string ("abc");                                     // Strong References softreference<string> softref=new softreference<string> (str);     // Soft References

When memory is low, it is equivalent to:

If (JVM. Insufficient memory ()) {   null;  // convert to Soft reference   // garbage collector for recycling }

Soft 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

Browser prev =NewBrowser ();//get page to browseSoftReference sr =NewSoftReference (prev);//after browsing is complete, set to soft referenceif(Sr.get ()! =NULL) {Rev= (Browser) sr.get ();//Has not been recovered by the collector, directly obtained}Else{prev=NewBrowser ();//because of the memory crunch, the soft-referenced objects are recycledSR =NewSoftReference (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.

String str=New string ("abc");    WeakReferenceNew weakreference<string>(str); str=null;

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

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:

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

 Public classReferencetest {Private StaticReferencequeue<verybig> RQ =NewReferencequeue<verybig>();  Public Static voidCheckqueue () {Reference<?extendsVerybig> ref =NULL;  while(ref = Rq.poll ())! =NULL) {            if(Ref! =NULL) {System.out.println ("In queue:" +( (verybigweakreference) (ref)). ID); }        }    }     Public Static voidMain (String args[]) {intSize = 3; LinkedList<WeakReference<VeryBig>> weaklist =NewLinkedlist<weakreference<verybig>>();  for(inti = 0; i < size; i++) {Weaklist.add (NewVerybigweakreference (NewVerybig ("Weak" +i), RQ); System.out.println ("Just created weak:" +weaklist.getlast ());         } System.GC (); Try{//rest for a few minutes and let the garbage collection thread above run to completionThread.CurrentThread (). Sleep (6000); } Catch(interruptedexception e) {e.printstacktrace ();    } checkqueue (); }}classVerybig { PublicString ID; //take up space for the thread to recycle    byte[] B =New byte[2 * 1024];  PublicVerybig (String id) { This. ID =ID; }    protected voidFinalize () {System.out.println ("Finalizing Verybig" +ID); }}classVerybigweakreferenceextendsWeakreference<verybig> {     PublicString ID;  PublicVerybigweakreference (Verybig big, referencequeue<verybig>RQ) {        Super(big, RQ);  This. ID =big.id; }    protected voidFinalize () {System.out.println ("Finalizing Verybigweakreference" +ID); }}

The result of the final output is:

210120

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:

Use the form to illustrate, as follows:

Reference documents:

1, http://www.cnblogs.com/skywang12345/p/3154474.html

2, Http://blog.csdn.net/lifetragedy?viewmode=contents

[strong reference to]java, weak reference, soft reference, virtual reference