A comprehensive comparison between PermGen (Permanent Generation) and Metaspace memory areas in the JVM.

1. Overview and Evolution

public class MemoryEvolution {
public static void main(String[] args) {
System.out.println("Java Memory Area Evolution:");
System.out.println("Java 7 and earlier: PermGen");
System.out.println("Java 8 and later: Metaspace");
// Check current Java version
System String javaVersion = System.getProperty("java.version");
System.out.println("Running Java: " + javaVersion);
if (javaVersion.startsWith("1.8") || javaVersion.startsWith("8")) {
System.out.println("Using Metaspace (Java 8+)");
} else if (javaVersion.startsWith("1.7") || javaVersion.startsWith("7")) {
System.out.println("Using PermGen (Java 7)");
}
}
}

2. PermGen (Permanent Generation) - Java 7 and earlier

Location: Part of JVM Heap memory

public class PermGenDemo {
// These would be stored in PermGen in Java 7:
// Class metadata
private static class PermanentClass {
static final String CONSTANT = "This stays in PermGen";
}
// String literals from pool
private String stringLiteral = "This string in PermGen";
// Static variables
private static List<String> staticList = new ArrayList<>();
// Method area information
public static void main(String[] args) {
// In Java 7, this could cause java.lang.OutOfMemoryError: PermGen space
loadMultipleClasses();
}
public static void loadMultipleClasses() {
for (int i = 0; i < 100000; i++) {
// Dynamic class loading - each class consumes PermGen
try {
Class<?> dynamicClass = Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
// PermGen JVM Flags (Java 7):
// -XX:PermSize=64m       // Initial PermGen size
// -XX:MaxPermSize=256m   // Maximum PermGen size
// -XX:+PrintGCDetails    // Monitor GC activity

3. Metaspace - Java 8 and later

Location: Native memory (off-heap)

public class MetaspaceDemo {
// In Java 8+, these are stored in Metaspace:
// Class metadata
private static class MetaClass {
static final String CONSTANT = "This stays in Metaspace";
}
// Method metadata
public void methodWithMetadata() {
// Method information stored in Metaspace
System.out.println("Method metadata in Metaspace");
}
public static void main(String[] args) {
System.out.println("Metaspace Demo - Java 8+");
// Monitor Metaspace usage
printMetaspaceInfo();
// Demonstrate class loading behavior
demonstrateClassLoading();
}
public static void printMetaspaceInfo() {
// Get Metaspace information (requires MXBean)
java.lang.management.ClassLoadingMXBean classLoadingMxBean = 
java.lang.management.ManagementFactory.getClassLoadingMXBean();
System.out.println("Loaded Class Count: " + classLoadingMxBean.getLoadedClassCount());
System.out.println("Total Loaded Classes: " + classLoadingMxBean.getTotalLoadedClassCount());
System.out.println("Unloaded Classes: " + classLoadingMxBean.getUnloadedClassCount());
}
public static void demonstrateClassLoading() {
// Create multiple classes to observe Metaspace behavior
for (int i = 0; i < 1000; i++) {
createDynamicClass(i);
}
}
private static void createDynamicClass(int index) {
// Simulate dynamic class creation
String className = "DynamicClass" + index;
// In real scenarios, this would be done with bytecode manipulation
}
}
// Metaspace JVM Flags (Java 8+):
// -XX:MetaspaceSize=64m          // Initial Metaspace size
// -XX:MaxMetaspaceSize=256m      // Maximum Metaspace size  
// -XX:MinMetaspaceFreeRatio=40   // Minimum free ratio after GC
// -XX:MaxMetaspaceFreeRatio=70   // Maximum free ratio after GC

4. Key Differences Comparison

public class PermGenVsMetaspace {
public static class Comparison {
// Feature comparison between PermGen and Metaspace
public static void main(String[] args) {
System.out.println("=== PermGen vs Metaspace Comparison ===");
System.out.println("\n1. LOCATION:");
System.out.println("PermGen: Part of JVM Heap memory");
System.out.println("Metaspace: Native memory (off-heap)");
System.out.println("\n2. MEMORY MANAGEMENT:");
System.out.println("PermGen: Fixed size, requires manual tuning");
System.out.println("Metaspace: Auto-expanding, better memory management");
System.out.println("\n3. GARBAGE COLLECTION:");
System.out.println("PermGen: Collected during Full GC, inefficient");
System.out.println("Metaspace: More efficient GC when classes are unloaded");
System.out.println("\n4. OUT OF MEMORY ERRORS:");
System.out.println("PermGen: java.lang.OutOfMemoryError: PermGen space");
System.out.println("Metaspace: java.lang.OutOfMemoryError: Metaspace");
System.out.println("\n5. DEFAULT SIZES:");
System.out.println("PermGen: Platform dependent (32MB-96MB)");
System.out.println("Metaspace: Limited by system memory");
}
}
// Content stored in both:
public static class StoredContent {
// Both PermGen and Metaspace store:
// Class metadata
private static class ExampleClass {
private int instanceField;
private static String staticField = "Static value";
}
// Method metadata
public void exampleMethod(String param) {
// Method bytecode and metadata stored here
System.out.println(param);
}
// Constant pool
private final String CONSTANT_STRING = "Constant pool entry";
// Annotations
@Deprecated
public void deprecatedMethod() {}
// Field metadata
private String instanceFieldMetadata;
}
}

5. Monitoring and Troubleshooting

public class MemoryMonitoring {
public static void monitorMemoryAreas() {
System.out.println("=== Memory Area Monitoring ===");
// Heap memory info
Runtime runtime = Runtime.getRuntime();
long maxMemory = runtime.maxMemory();
long totalMemory = runtime.totalMemory();
long freeMemory = runtime.freeMemory();
System.out.printf("Heap - Max: %dMB, Total: %dMB, Free: %dMB%n",
maxMemory / (1024 * 1024),
totalMemory / (1024 * 1024),
freeMemory / (1024 * 1024));
// Class loading info (indirect Metaspace monitoring)
java.lang.management.ClassLoadingMXBean clBean = 
java.lang.management.ManagementFactory.getClassLoadingMXBean();
System.out.printf("Classes - Loaded: %d, Total Loaded: %d, Unloaded: %d%n",
clBean.getLoadedClassCount(),
clBean.getTotalLoadedClassCount(),
clBean.getUnloadedClassCount());
}
// Simulate Metaspace issues
public static class MetaspaceIssueSimulator {
private static List<Class<?>> loadedClasses = new ArrayList<>();
public static void simulateMetaspaceLeak() {
// This would require bytecode generation in real scenario
// Simulating by loading many classes
for (int i = 0; i < 10000; i++) {
try {
// Load system classes (in real scenario, generate dynamic classes)
Class<?> stringClass = Class.forName("java.lang.String");
loadedClasses.add(stringClass);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
// JVM Flags for monitoring:
// -XX:+PrintFlagsFinal          // Show all JVM flags
// -XX:+PrintGCDetails           // Detailed GC logging
// -XX:+PrintClassHistogram      // Class histogram before full GC
// -Xlog:gc*                     // Comprehensive GC logging (Java 9+)

6. Common Issues and Solutions

public class CommonIssues {
// PermGen Issues (Java 7 and earlier)
public static class PermGenIssues {
// Common causes of PermGen errors:
// 1. Excessive class loading
public void excessiveClassLoading() {
// Hot deployment without proper cleanup
// Multiple redeploys in application servers
}
// 2. String intern abuse
public void stringInternIssues() {
String largeString = "Very large string value...";
// Calling intern() too frequently can fill PermGen
largeString = largeString.intern();
}
// 3. Dynamic class generation
public void dynamicClassGeneration() {
// Libraries like ASM, CGLIB generating many classes
// Without proper cleanup
}
}
// Metaspace Issues (Java 8+)
public static class MetaspaceIssues {
// Common causes of Metaspace errors:
// 1. Memory leaks from classloaders
public void classLoaderLeaks() {
// Custom classloaders not being garbage collected
// Holding references to generated classes
}
// 2. Excessive dynamic proxy generation
public void proxyGeneration() {
// Frameworks generating many dynamic proxies
// Spring AOP, Hibernate, etc.
}
// 3. Large applications with many dependencies
public void largeApplication() {
// Microservices with numerous libraries
// Each library contributing to Metaspace usage
}
}
// Solutions for both
public static class Solutions {
public void generalSolutions() {
// 1. Monitor memory usage
monitorMemoryAreas();
// 2. Set appropriate memory limits
// For PermGen: -XX:MaxPermSize=256m
// For Metaspace: -XX:MaxMetaspaceSize=512m
// 3. Use application server features properly
// Proper undeployment of applications
// 4. Avoid memory leaks in custom classloaders
cleanupClassLoaders();
}
private void monitorMemoryAreas() {
// Regular monitoring implementation
MemoryMonitoring.monitorMemoryAreas();
}
private void cleanupClassLoaders() {
// Ensure classloaders can be garbage collected
// Don't hold static references to classes from custom classloaders
}
}
}

7. Practical Examples and Best Practices

public class BestPractices {
// Application with good memory practices
public static class WellBehavedApplication {
private static final Logger logger = LoggerFactory.getLogger(WellBehavedApplication.class);
// Use weak references for caching classes
private final WeakHashMap<String, Class<?>> classCache = new WeakHashMap<>();
public void loadClassSafely(String className) {
try {
Class<?> loadedClass = Class.forName(className);
// Cache weakly - allows GC when needed
classCache.put(className, loadedClass);
} catch (ClassNotFoundException e) {
logger.error("Class not found: {}", className, e);
}
}
public void cleanup() {
// Explicit cleanup when possible
classCache.clear();
}
}
// Demonstrating proper classloader usage
public static class ProperClassLoaderUsage {
public static void demonstrateIsolation() {
// Custom classloader for isolation
ClassLoader customLoader = new CustomClassLoader();
try {
// Load classes through custom classloader
Class<?> isolatedClass = customLoader.loadClass("com.example.SomeClass");
// When done, allow classloader to be GC'd
customLoader = null;
System.gc(); // Suggest GC
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
static class CustomClassLoader extends ClassLoader {
// Custom classloader implementation
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
// Custom loading logic
return super.loadClass(name);
}
}
}
// Recommended JVM configurations for different scenarios:
public class JVMConfigurations {
// Development environment
public static class Development {
// -Xms512m -Xmx1024m 
// -XX:MaxMetaspaceSize=256m
// -XX:+UseG1GC
}
// Production environment - web application
public static class ProductionWebApp {
// -Xms2g -Xmx4g
// -XX:MaxMetaspaceSize=512m
// -XX:+UseG1GC
// -XX:MaxGCPauseMillis=200
}
// Production environment - microservice
public static class ProductionMicroservice {
// -Xms512m -Xmx512m  // Fixed heap for container
// -XX:MaxMetaspaceSize=256m
// -XX:+UseSerialGC   // For small heaps
}
}

8. Migration from Java 7 to Java 8+

public class MigrationGuide {
public static void migrateFromPermGenToMetaspace() {
System.out.println("=== Migration from Java 7 to Java 8+ ===");
System.out.println("\nBEFORE (Java 7):");
System.out.println("-XX:PermSize=64m");
System.out.println("-XX:MaxPermSize=256m");
System.out.println("-XX:+CMSClassUnloadingEnabled");
System.out.println("\nAFTER (Java 8+):");
System.out.println("-XX:MetaspaceSize=64m");
System.out.println("-XX:MaxMetaspaceSize=256m");
System.out.println("// CMSClassUnloadingEnabled not needed");
System.out.println("\nNOTES:");
System.out.println("1. Remove all PermSize/MaxPermSize flags");
System.out.println("2. Replace with MetaspaceSize/MaxMetaspaceSize if needed");
System.out.println("3. Monitor Metaspace usage in production");
System.out.println("4. Most applications work fine with defaults");
}
// Common migration issues and solutions
public static class MigrationIssues {
public void handleCommonProblems() {
// Issue 1: OutOfMemoryError after migration
// Solution: Increase MaxMetaspaceSize or find memory leaks
// Issue 2: Performance regression
// Solution: Tune GC settings, monitor class loading
// Issue 3: Tools compatibility
// Solution: Update monitoring tools to understand Metaspace
}
}
}

Key Takeaways

1. PermGen was part of heap memory, Metaspace uses native memory
2. Metaspace auto-grows and has better memory management
3. Metaspace garbage collection is more efficient
4. Both store class metadata, but Metaspace handles it more effectively
5. Migration from Java 7 to 8+ requires removing PermGen flags
6. Monitor Metaspace usage in production environments
7. Use appropriate JVM flags based on your application's needs

The move from PermGen to Metaspace in Java 8 was a significant improvement that eliminated many memory management issues and provided better performance for modern applications.