{"id":598,"date":"2011-10-27T21:08:00","date_gmt":"2011-10-27T21:08:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/java-secret-loading-and-unloading-static-fields.html"},"modified":"2012-10-21T20:23:12","modified_gmt":"2012-10-21T20:23:12","slug":"java-secret-loading-and-unloading","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/10\/java-secret-loading-and-unloading.html","title":{"rendered":"Java Secret: Loading and unloading static fields"},"content":{"rendered":"
\n

OVERVIEW<\/h2>\n

To start with it is natural to assume that static fields have a special life cycle and live for the life of the application. You could assume that they live is a special place in memory like the start of memory in C or in the perm gen with the class meta information.<\/p>\n

However, it may be surprising to learn that static fields live on the heap, can have any number of copies and are cleaned up by the GC like any other object.<\/p>\n

This follows on from a previous discussion; Are static blocks interpreted?<\/a><\/p>\n

LOADING STATIC FIELDS<\/h2>\n

When a class is obtained for linking it may not result in the static block being intialised.<\/p>\n

A simple example<\/p>\n

public class ShortClassLoadingMain {\r\n    public static void main(String... args) {\r\n        System.out.println(\"Start\");\r\n        Class aClass = AClass.class;\r\n        System.out.println(\"Loaded\");\r\n        String s= AClass.ID;\r\n        System.out.println(\"Initialised\");\r\n    }\r\n}\r\n\r\nclass AClass {\r\n    static final String ID;\r\n    static {\r\n        System.out.println(\"AClass: Initialising\");\r\n        ID = \"ID\";\r\n    }\r\n}\r\n<\/pre>\n
prints<\/p>\n
Start\r\nLoaded\r\nAClass: Initialising\r\nInitialised\r\n<\/pre>\n
You can see you can obtain a reference to a class, before it has been initialised, only when it is used does it get initialised.<\/p>\n
LOADING MULTIPLE COPIES OF A STATIC FIELD<\/h2>\n
Each class loader which loads a class has its own copy of static fields. If you load a class in two different class loaders these classes can have static fields with different values.
 
<\/div> <\/div><\/p>\n
UNLOADING STATIC FIELDS<\/h2>\n
static fields are unloaded when the Class’ ClassLoader is unloaded. This is unloaded when a GC is performed and there are no strong references from the threads’ stacks.<\/p>\n
PUTTING THESE TWO CONCEPTS TOGETHER<\/h2>\n
Here is an example where a class prints a message when it is initialised and when its fields are finalized.<\/p>\n
class UtilityClass {\r\n    static final String ID = Integer.toHexString(System.identityHashCode(UtilityClass.class));\r\n    private static final Object FINAL = new Object() {\r\n        @Override\r\n        protected void finalize() throws Throwable {\r\n            super.finalize();\r\n            System.out.println(ID + \" Finalized.\");\r\n        }\r\n    };\r\n\r\n    static {\r\n        System.out.println(ID + \" Initialising\");\r\n    }\r\n}\r\n<\/pre>\n
By loading this class repeatedly, twice at a time<\/p>\n
for (int i = 0; i < 2; i++) {\r\n  cl = new CustomClassLoader(url);\r\n  clazz = cl.loadClass(className);\r\n  loadClass(clazz);\r\n\r\n  cl = new CustomClassLoader(url);\r\n  clazz = cl.loadClass(className);\r\n  loadClass(clazz);\r\n  triggerGC();\r\n}\r\ntriggerGC();\r\n<\/pre>\n
you can see an output like this  <\/p>\n
1b17a8bd Initialising\r\n2f754ad2 Initialising\r\n\r\n-- Starting GC\r\n1b17a8bd Finalized.\r\n-- End of GC\r\n\r\n6ac2a132 Initialising\r\neb166b5 Initialising\r\n\r\n-- Starting GC\r\n6ac2a132 Finalized.\r\n2f754ad2 Finalized.\r\n-- End of GC\r\n\r\n\r\n-- Starting GC\r\neb166b5 Finalized.\r\n-- End of GC\r\n<\/pre>\n
In this log, two copies of the class are loaded first. The references to the first class\/classloader are overwritten by references to the second class\/classloader. The first one is cleaned up on a GC, the second one is retained. On the second loop, two more copies are initialised. The forth one is retained, the second and third are cleaned up on a GC. Finally the forth copy of the static fields are cleaned up on a GC when they are no longer references.<\/p>\n
THE CODE<\/h2>\n
The first example – ShortClassLoadingMain<\/a> The second example – LoadAndUnloadMain<\/a><\/p>\n
Reference: <\/i><\/strong>Java Secret: Loading and unloading static fields<\/a> from our JCG partner<\/a> Peter Lawrey<\/a> at the Vanilla Java<\/a>.<\/p>\n
Related Articles:<\/strong><\/div>\n