Understanding the Role of Metaspace in Java: Are Static Methods and Fields Included?

Dive into the world of Java memory management as we explore whether static methods and fields reside in `metaspace`, and clarify the relationship between `metaspace`, heap memory, and native memory.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Are static methods/fields/blocks part of metaspace? Is metaspace apart of heap and is in native memory?

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Role of Metaspace in Java

Java developers often encounter confusion around memory management, particularly when discussing terms like metaspace, heap, and static fields. In this post, we’ll dissect these concepts to clarify the role of metaspace in Java 13, shedding light on whether static methods, fields, and blocks are part of this memory region.

The Core of the Query

The original question revolves around two major issues:

Where do methods and other code reside, static or not?

Where do static fields go in memory?

Let’s tackle these questions one at a time to gain a better understanding of Java’s memory architecture.

Where Do Methods and Other Code Go?

Understanding Static and Non-Static Methods

It’s essential to realize that both static and non-static methods exist as blocks of code in memory. In practical terms:

Static methods belong to the class itself and can be invoked without creating an instance of the class.

Non-static methods, while still a part of the class, require an instance of the class to access member variables. However, the underlying code for these methods still exists in a singular location.

An illustrative example is as follows:

[[See Video to Reveal this Text or Code Snippet]]

In this example:

Both methods a() and b() are essentially stored once, regardless of how many instances of Foo are created, ensuring efficient memory usage.

The JVM and Method Storage

Java utilizes a component known as HotSpot Compiler that optimizes method execution by keeping track of various statistics about method usage:

Number of invocations

Overriding possibilities

The JVM may then rewrite frequently used methods into optimized machine code, but importantly, the original bytecode remains intact in memory. This means there can be two representations of the same method:

Original Bytecode: The baseline code that represents the method.

Optimized Variant: A compiled version designed for faster execution.

Where This Resides in Memory

The specific storage details within the JVM for methods and code are not strictly defined in Java’s specifications. Generally, Java's metaspace and earlier memories like PermGen serve to hold this information.

Where Do Static Fields Go?

Memory Allocation for Static Fields

When it comes to static fields, these do not occupy space in metaspace; instead, they reside in the heap memory. Here’s a breakdown:

This means that as long as the class is loaded in the JVM, the static field persists in memory, making it ineligible for garbage collection unless the class itself is unloaded.

In summary, static fields remain associated with their classes, residing in the heap memory while not being part of the metaspace

Conclusion

To sum it up, the relationship between static methods, static fields, and the metaspace can be confusing. Here's what we've established:

Methods (both static and non-static) exist in memory once as blocks of code,** typically held in metaspace.

Static fields are stored in the heap and affiliated with the class, not residing in metaspace.

By understanding these distinctions, Java developers can better navigate memory management and optimize their applications. The dynamic nature of Java’s environment ensures that while methods and their code management can be complex, knowledge is the key to efficiency.