What is the actual memory place for static variables?

A static variable is allocated for the entire duration of a program's execution, so neither stack nor heap are conv开发者_如何转开发enient for it. Then where is that variable? Shouldn't there be some place where it is loaded from?

We have 3 segments in our memory:

1. Stack Segment — contains local variables and Reference variables (variables that hold the address of an object in the heap).

2. Heap Segment — contains all created objects in runtime, objects only plus their object attributes (instance variables).

3. Code Segment — the segment where the actual compiled Java bytecodes resides when loaded. Static members (variables or methods) are called class members, meaning they reside where the class (bytecode) resides, which is in the Code Segment.

Static fields are initialised when a class is loaded and are discarded when the classloader for that class is unloaded. They can be cleaned up, even duplicated in another class loader.

For applications like those that use OSGi, static variables don't live for the whole life of the application. They can be reloaded many times.

How this is implement may be JVM dependent, but the Sun/Oracle JVM creates an "object" to hold the static fields for a class. This object is accessible via the Unsafe class which can also be used to examine this "objects" fields.

Static variable is allocated for the entire duration of program's execution, so neither stack nor heap are convenient for it.

In fact, static frames (i.e. the frames that hold the static variables) ARE allocated from the heap.

And they don't necessarily exist for the duration of a program's execution. For instance, static frames for classes that are dynamically loaded can be garbage collected if the parent classloader, all classes and all instances becomes unreachable.

Out of five memory areas that JVM uses, the static fields are allocated memory in Class Area(part of PremGen) when the class is loaded by the Application class loader during prepare and loading phase. If the field is primitive, the value is stored in the class area and if it is of Object type (new operator used), it is stored in heap but the reference is given to the assigned static field variable in class area. When the class is unloaded, the memory for that static field is also available to be garbage collected by GC.

If the field is final as well, that is, static final, it is kept in constant pool under class area.

From http://www.daniweb.com/software-development/java/threads/34695:

Static variable's memory is allocated at the start of the program, in regular memory, instead of the stack (memory set aside specifically for the program). the advantage of this is that it makes your variable or procedure totally constant, and you can't accidentally change the value. the disadvantage of this is that the memory is not deallocated until the program is terminated. I have never heard anything that static values take any more memory than if they are declared regularly, but thier memory use is constant throught.

The static variables are provided the memory in the the same memory segment where the code is stored i.e. Class Area. It is independent of the stack or heap segment of memory. It remains accessible during the complete duration of the program.

Static varibales are shared variables for whole the classs, If one object change the value of variable it will be changed for every object of class