Understanding storage of static methods and static variables in Java

In every programming language, memory is a vital resource and is also scarce. Hence the memory must be managed thoroughly without any leaks. Allocation and deallocation of memory is a critical task and requires a lot of care and consideration. In this article, we will understand the storage of static methods and static variables in Java. Java Virtual Machine(JVM) is an engine providing a runtime environment for Java code. It converts Java bytecode into machine language, enabling Java programs to run on any device or OS, adhering to the Write Once Run Anywhere (WORA) principle. Additionally, the JVM manages and optimizes program memory.

Memory Pools in JVM

During runtime, the JVM memory manager creates memory pools, primarily the stack memory and the heap memory.

Stack Memory:

Purpose: Stack memory is used to store method calls and local variables, which are small in size and have a short lifespan.

Characteristics: Stack memory is thread-specific, meaning each thread has its own stack. The memory allocation and deallocation are automatically managed by the JVM and follow a Last In, First Out (LIFO) order.

Heap Memory:

Purpose: Heap memory is used to store all instances of objects, which have a longer lifespan.

Characteristics: Heap memory is shared among all threads. Memory allocation here is more complex compared to stack memory and requires garbage collection to free up unused objects.

Learn More, stack memory and heap memory

When we instantiate an object using the new keyword, memory is allocated on the heap, and the address of this memory is stored on the stack. The main difference between stack memory and the heap memory is that the stack is used to store only the small datatypes whereas heap stores all the instances of the class. In order to get a better understanding of how the new keyword works, let's take an example. Let's take a bird class. Whenever a new bird is found, the number of birds need to be incremented. Let's try to implement this code: 

class Bird {
    private String name;
    private int number; // Instance variable

    Bird(String name) {
        this.name = name;
        number++;
    }

    public void fly() {
        System.out.println("This bird flies");
    }

    public int getNumber() {
        return number;
    }

    public String getName() {
        return name;
    }
}

class GFG {
    public static void main(String args[]) {
        Bird b1 = new Bird("Parrot");
        Bird b2 = new Bird("Sparrow");
        Bird b3 = new Bird("Pigeon");

        System.out.println(b1.getNumber()); // Output: 1
    }
}

1

Clearly, this method cannot be used to count the number of birds because at every instance, a new heap is being allocated and for all the instances, the number of birds is being initialized from 0 and is incremented to 1. Therefore, we are creating three independent birds where, in every bird object, the number of birds is 1. In order to avoid this, we initialize the methods and variables as static. This means that the variable or method is not changed for every new object creation.

Using Static Variables

To correctly count the number of bird instances, we use a static variable. Static methods and variables belong to the class rather than any instance, ensuring they remain unchanged across all instances. They are stored in a special area called the permanent generation (PermGen) in Java 5 and 6, and in MetaSpace in Java 8 and later. Let's implement this by changing the number to a static variable. 

class Bird {
    private String name;
    private static int number = 0; // Static variable

    Bird(String name) {
        this.name = name;
        number++;
    }

    public void fly() {
        System.out.println("This bird flies");
    }

    public static int getNumber() { // Static method to access static variable
        return number;
    }

    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String args[]) {
        Bird b1 = new Bird("Parrot");
        Bird b2 = new Bird("Sparrow");
        Bird b3 = new Bird("Pigeon");

        System.out.println(Bird.getNumber()); // Output: 3
    }
}

3

Static Variable Solution: The number variable is declared as static, meaning it is shared among all instances of the Bird class. This ensures that the variable is incremented correctly each time a new Bird object is created.

Storage of Static Methods and Static Variables

1. Static Variables:

Static variables are class-level variables declared with the static keyword. They are shared across all instances of the class.

Memory Allocation:

Class Area (Metaspace): Static variables are stored in the class area, which in Java 8 and later versions is part of Metaspace. This area is dedicated to storing class-level information, including static variables.

Lifecycle: The lifecycle of static variables coincides with the lifecycle of the class. They are loaded into Metaspace when the class is loaded by the JVM and removed when the class is unloaded.

2. Static Methods:

Static methods are class-level methods declared with the static keyword. They can be called without creating an instance of the class.

Memory Allocation:

Class Area (Metaspace): Static methods are also stored in the class area within Metaspace. The method's bytecode and related metadata are stored here.

Execution: When a static method is invoked, its execution frame is created on the thread's stack, just like any other method.

PermGen vs. MetaSpace

In Java 5 and 6, static methods and variables were stored in PermGen. However, Java 8 introduced significant changes to the memory model, replacing PermGen with MetaSpace. MetaSpace stores class metadata, including names, fields, methods, bytecodes, constant pools, and JIT optimizations.

Key Differences:

• Heap Memory: Auto-growing space limited by RAM constraints.
• PermGen: Fixed space shared by all instances.
• MetaSpace: Introduced in Java 8, improving garbage collection performance and overcoming the challenge of predicting PermGen size.

Conclusion

Static methods and variables in Java are crucial for managing shared data across instances, stored in PermGen (Java 5 and 6) or MetaSpace (Java 8 and later). Understanding these memory management aspects ensures efficient Java application performance.The transition from PermGen to Metaspace in Java 8 has significantly improved the way the JVM handles class metadata and static variables. By dynamically sizing the Metaspace and utilizing native memory, Java applications can better manage memory and avoid common issues associated with the fixed-size PermGen.