Understanding Memory Management in Java
Memory management is one of the most critical aspects of any programming language. Java abstracts away most of the low-level memory management tasks. This makes it more secure and less error-prone compared to languages like C/C++.
Java Virtual Machine (JVM)
JVM is a virtual machine that enables a computer to run programs that compiled to Java bytecode. It is the one that actually calls the main method in our code. It is a specification, not an implementation.
JVM is the one that makes Write Once Run Anywhere (WORA) slogan possible. Different implementations become interoperable by following this specification when implementing JVM. Thus, Java programs can run on different machines independently of underlying hardware.
JVM Memory Structure
JVM divides its memory into several components, each serving a special purpose.
Method Area: When a Java program is executed, Class Loader in JVM loads classes as they are referenced (needed). When a class is loaded JVM generates several pieces of information such as field and method data, method bytecode and runtime constants. Then it stores these information in the method area. Method area is shared among all threads of a Java application.
Stack Area: This area used for managing method invocations and local variables. Each thread in a Java program has its own stack that is created when associated thread is created. After a thread terminates JVM destroys the stack associated with it.
PC Registers: Each thread also has a program counter registers associated with it that store the address of currently executing instruction of a thread.
Native Method Stacks: For each thread, there is a native method stack for native methods implemented in other languages such as C/C++. Java Native Interface (JNI) calls these stacks.
Heap: Runtime data area which stores information of all objects. It is created when JVM starts up. Objects created with the new keyword are stored here, while their references are stored in stack area. Heap consists of two parts called Young Generation and Old Generation in Java 8 and later versions.
Automatic Memory Allocation and Garbage Collection
In languages like C when we want to create an object, we first need to allocate space from heap. When we no longer need that object, we must deallocate that memory space. The reason for this is that the objects we create throughout the program can fill up the memory, causing the program to crash or causing memory leak. This process, which needs to be done manually by the programmer in languages such as C, is performed automatically in Java.
When a Java program creates an object with “new” keyword, it is stored in heap area. As the program creates more and more objects heap memory can become full. For this reason, garbage collector periodically runs in the background, looks at heap memory time to time, identifies which objects are currently used by a program and which are not. Then it deletes the unused objects to reclaim that memory. This process optimizes memory usage and results in better performance.
Basic garbage collection process can be described as follows.
Generational Garbage Collection
Most objects in a program have short lifetimes. This means that the majority of objects become garbage relatively quickly after being created. However, some objects in an application have longer lifetimes and continue to be referenced for a more extended period. For this reason, a heap structure that separates objects that have short lifetimes from objects with longer lifetimes. In this way, instead of processing all objects, the garbage collector can focus on Young Generation, where new objects are created. Garbage collector can reduce the load on it and increase performance by working less in Old Generation, where the objects with a longer lifetime resides.
Minor Garbage Collection: Young generation garbage collection
Major Garbage Collection (Full GC): GC scans the entire heap
Generational garbage collection process can be described as follows.
When the eden space fills up, a minor garbage collection is triggered.
Garbage Collector Options
Serial GC: Uses single thread for garbage collection
Parallel GC: Uses multiple threads for garbage collection
Concurrent Mark-Sweep (CMS) Garbage Collector, Garbage-First (G1) Garbage Collector…
Garbage Collector Tuning
Process of optimizing the performance of the garbage collector in a Java application by adjusting various garbage collector settings and options.
- Monitor and profile the application’s garbage collection behavior with tools like VisualVM
- Choose the right garbage collector
- Tune its behavior by adjusting various JVM options such as heap size, thread count related to garbage collection.
Memory Management Best Practices
String Handling: Java strings are immutable, which means each modification creates a new string object. Be mindful of string concatenation within loops, as it can lead to unnecessary object creation. Use StringBuilder or StringBuffer for more efficient string manipulation, especially when dealing with extensive string concatenations.
Use Primitive Data Types: Prefer using primitive data types instead of their corresponding wrapper classes (e.g., int instead of Integer). This reduces memory overhead.
Collection Sizing: When using collections like ArrayList or HashMap, consider initializing them with an appropriate initial capacity if you know the approximate size they will hold. This can prevent frequent resizing and memory reallocation.
Avoid Unnecessary Object Creation: Avoid creating objects unnecessarily, especially inside loops. Reusing objects or using object pooling can reduce memory allocation overhead.
Properly Close Resources: When using resources like files, database connections, or network sockets, make sure to close them properly when they are no longer needed. Failing to close resources can lead to resource leaks and increased memory usage.
