Skip to main content

Java: Strong References, Soft References and Weak References

There are many use-cases where we want to control, when our objects are collected by GC(Garbage Collector). Package "java.lang.ref" provides reference-object classes, which support a limited degree of interaction with the garbage collector. And GC reclaim the object memory based on it's reachability.

Strong Reference

Newly created objects are strongly reachable by the thread that created it. So object will be remain in heap till thread is running or some variable hold this object reference.

//leaking array
private static List<String> leakingArrayWithStrongRef = 
                                new LinkedList<String>();

    public void StrongReferenceTest(){
        try {
            for (int i = 0; i < 500000; i++) {
                String data = LEAKING_DATA + i;
                // Add data to our leaking array...
                leakingArrayWithStrongRef.add(data);
            }
        } catch (OutOfMemoryError ofm) {
            System.out.println("OutOfMemoryError");
        } catch (Throwable e) {
            System.out.println("UnexpectedError");
        }        
    }



imageHeap Memory trend chart when unwanted objects added in Array

In this example array hold the strong reference of string. As we start adding string object in array then heap memory increase to it's max limit and throws "OutOfMemoryEerror" exception.



Soft Reference

Soft Reference are the softly reachable object. These kind of object will remain in the heap memory till GC clean them out in need of memory.


//leaking array
private static List<SoftReference<String>> leakingArrayWithSoftRef = 
                                new LinkedList<SoftReference<String>>();

    public void SoftReferenceTest(){
        try {
            for (int i = 0; i < 500000; i++) {
                SoftReference<String> data = new SoftReference<String>(LEAKING_DATA + i);
                // Add data to our leaking array...
                leakingArrayWithSoftRef.add(data);
            }
        } catch (OutOfMemoryError ofm) {
            System.out.println("OutOfMemoryError");
        } catch (Throwable e) {
            System.out.println("UnexpectedError");
        }     
    }



imageHeap Memory trend chart when unwanted objects added in Array

In this example array hold the soft reference of string object. As we start adding string object in array then heap memory increase to it's max limit and GC reclaim the soft reference object from heap. And in this code you will not get "OutOfMemoryEerror".



Weak Reference

Weak Reference are weakly reachable objects. And these kind of object will reclaim by the GC at any point of time.


//leaking array
private static List<WeakReference<String>> leakingArrayWithWeakRef = 
                                new LinkedList<WeakReference<String>>();

    public void WeakReferenceTest(){
        try {
            for (int i = 0; i < 500000; i++) {
                WeakReference<String> data = new WeakReference<String>(LEAKING_DATA + i);
                // Add data to our leaking array...
                leakingArrayWithWeakRef.add(data);
            }
        } catch (OutOfMemoryError ofm) {
            System.out.println("OutOfMemoryError");
        } catch (Throwable e) {
            System.out.println("UnexpectedError");
        }       
    }



image Heap Memory trend chart when unwanted objects added in Array



In this example array hold the weak reference of string object. As we start adding string object in array then heap memory start increasing slightly and decrease after few seconds. It's happen because GC clean these object from the array more frequently. And in this code you will not get "OutOfMemoryEerror".



PS: I have used "jconsole.exe" to generate above graphs, which comes as a part of "JDK" toolkit.

Popular posts from this blog

ERROR: Ignored call to 'alert()'. The document is sandboxed, and the 'allow-modals' keyword is not set.

Recently I found this issue while writing code snippet in "JSFiddle". And after searching, found this was happening because of new feature added in "Chrome 46+". But at the same time Chrome doesn't have support for "allow-modals" property in "sandbox" attribute.

Chromium issue for above behavior:
https://codereview.chromium.org/1126253007

To make it work you have to add "allow-scripts allow-modals" in "sandbox" attribute, and use "window.alert" instead of "alert".



<!-- Sandbox frame will execute javascript and show modal dialogs --> <iframe sandbox="allow-scripts allow-modals" src="iframe.html"> </iframe>


Feature added: Block modal dialog inside a sandboxed iframe.
Link: https://www.chromestatus.com/feature/4747009953103872

Feature working Demo page:
https://googlechrome.github.io/samples/block-modal-dialogs-sandboxed-iframe/index.html



CSS Specificity

Many time different CSS rules overlap on one or more element. And some people always get confuse about, which rule will take higher priority then other and why? CSS Specificity is the answer of all these kind of questions.
As the name suggest, the CSS rule which is more specific to the element will take higher priority then other. Means something like “#some_id{}” will always take higher priority then “*{}” universal selector.  And if duplicate rules are define then the last rule will be applied to the element.

The following list of selectors is by increasing specificity:
Type selector (e.g., div) and pseudo-elements in selector (e.g., :after) Class selectors (e.g., .some_class), attributes selectors (e.g., [type=”radio”]) and pseudo-class selector (e.g., :hover) Id selectors (e.g., #some_id)


ID takes higher priority then Class, Type and Universal selector (Note: Universal selector has no effect on specificity, see below special conditions). 



If duplicate rules are given, then last…

Guava: Some useful IO utilities

Guava IO package provides very useful utility classes for input/ouput stream, byte stream, file handling and many more. Here are few example which show case how these utilities can make your code much cleaner, modular and more readable.Copy “InputStream” to “OutputStream InputStream is = CopyStreams.class.getResourceAsStream("test.txt"); OutputStream os = System.out; ByteStreams.copy(is, os);Changing InputStream to “byte[]” InputStream is = CopyStreams.class.getResourceAsStream("test.txt"); byte[] isBytes = ByteStreams.toByteArray(is); // Now if you want to get base64 encoded string then it will be like this String isBase64Str = new sun.misc.BASE64Encoder().encode(isBytes);Combining two files in one File input1 = new File("c:\\testio\\AWords.txt"); File input2 = new File("c:\\testio\\BWords.txt"); File output = new File("c:\\testio\\ABWords.txt"); …