Fundamentals of Java 7-strong references, 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();   //  强引用

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;     // 帮助垃圾收集器回收此对象

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();// 省略其他操作}

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.

The

Strong reference is very important in practice, for example, a ArrayList implementation source code:

private transient  object[] elementdata; public void clear ()  {         modCount++;         // let gc do its 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");                                     // 强引用 SoftReference<String> softRef=new SoftReference<String>(str);     // 软引用

When memory is low, it is equivalent to:

If(JVM.内存不足()) {   str = null;  // 转换为软引用   System.gc(); // 垃圾回收器进行回收}

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

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 (); //have not been recycled by the collector, get it directly}               Else{prev = new Browser ();       //Due to memory crunch, sr = new SoftReference (prev) is recycled for soft-referenced objects; //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");    WeakReference<String> abcWeakRef = new WeakReference<String>(str);str=null;

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

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:

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.

PublicClassReferencetest{PrivateStatic referencequeue<verybig> RQ =New Referencequeue<verybig> ();PublicStaticvoidCheckqueue(){reference<? extends verybig> ref =Nullwhile (ref = Rq.poll ())! =NULL) {if (ref! =NULL) {SYSTEM.OUT.PRINTLN ("In queue:" + ((verybigweakreference) (ref)). id);}}}PublicStaticvoidMain(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 {Rest a few minutes below and let the garbage collection thread above run to finish Thread.CurrentThread (). Sleep (6000);}catch (Interruptedexception e) {e.printstacktrace ();} Checkqueue ();}}ClassVerybig{public String ID;Take up space for the thread to recycleByte[] B =Newbyte[2 *1024];Public Verybig(String ID){this.id = ID;}ProtectedvoidFinalize(){System.out.println ("Finalizing Verybig" + ID);}}ClassVerybigweakreferenceExtendsWeakReference<Verybig> {public String ID;PublicVerybigweakreference (verybig big, referencequeue<verybig> &NBSP;RQ)  {super (BIG,&NBSP;RQ);  This.id = big.id;} protected   Void  finalize ()  {system.out.println ( "finalizing  verybigweakreference  " + id);}           

The result of the final output is:

Just createdweak: com.javabase.reference.verybigweakreference @1641c0just created weak:  Com.javabase.reference.verybigweakreference@136ab79just created weak: com.javabase.reference.verybigweakreference@ 33c1aafinalizing verybig weak 2finalizing verybig weak  1finalizing verybig weak 0In < Span class= "Hljs-attribute" >queue: weak 1in  queue: weak 2in  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:

Portal: Java Memory management http://blog.csdn.net/mazhimazh/article/category/1907599

Use the form to illustrate, as follows:

Fundamentals of Java 7-strong references, weak references, soft references, virtual references