Metaspace

// ── What triggers Metaspace growth ───────────────────────────────────

// 1. Loading new classes — each class consumes Metaspace
ClassLoader cl = new URLClassLoader(new URL[]{jarUrl});
Class<?> clazz = cl.loadClass("com.example.MyClass");
// MyClass's metadata now occupies Metaspace

// 2. JIT compilation — compiled methods stored in Metaspace (CodeCache)
// As methods get hot and are JIT-compiled, CodeCache grows
// CodeCache is adjacent to but distinct from Metaspace

// 3. Dynamic class generation — frameworks that generate proxy classes
// These frameworks add classes to Metaspace:
// - Spring AOP (CGLIB proxies, JDK proxies)
// - Hibernate (proxy entities for lazy loading)
// - Jackson (serialiser/deserialiser classes)
// - Java Reflection (Method, Constructor access classes)
// - Mockito (mock subclasses)
// - Bytecode manipulation (ASM, ByteBuddy, Javassist)

// 4. Class reloading in dev mode (Spring DevTools, JRebel)
// New versions of classes are loaded while old versions wait for GC
// Both old and new consume Metaspace until old classloaders are GC'd

// ── Metaspace layout (HotSpot) ────────────────────────────────────────
// Class space:       holds per-class InstanceKlass structures
//                    (with compressed class pointers, typically 1GB limit)
// Non-class space:   all other metadata (methods, constants, etc.)
//
// JVM flags:
// -XX:MetaspaceSize=<size>       initial Metaspace size (triggers GC at this threshold)
// -XX:MaxMetaspaceSize=<size>    maximum (default: unlimited — set this in production!)
// -XX:CompressedClassSpaceSize=<size>  limit for class space (default 1GB)

// ── Monitoring Metaspace ──────────────────────────────────────────────
// jcmd <pid> VM.metaspace
// jstat -gc <pid>    (displays MC: Metaspace Capacity, MU: Metaspace Used)
// jmap -clstats <pid>  (class loader statistics)

// GC log entry showing Metaspace change:
// [gc] Pause Full (Metadata GC Threshold) 512M->180M(1024M) 345.ms
//                 ↑                                         ↑
//   Metaspace threshold triggered the GC        full heap GC occurred

// ── When Metaspace IS reclaimed (class unloading) ────────────────────
// Condition: ClassLoader becomes unreachable

URLClassLoader loader = new URLClassLoader(urls);
Class<?> clazz = loader.loadClass("com.example.Plugin");
Object plugin = clazz.getDeclaredConstructor().newInstance();

// Make everything unreachable:
plugin = null;   // no live instances of Plugin
clazz  = null;   // no live Class<Plugin> references
loader = null;   // ClassLoader is now unreachable

System.gc();     // encourage (not guarantee) GC

// After GC: loader collected → Plugin metadata freed from Metaspace

// ── Metaspace leak — ClassLoader retained by accident ─────────────────
// LEAK: static field holds reference to an instance of a hot-deployed class
public class AppServer {

    // This static field in the SERVER's ClassLoader holds an instance
    // of Plugin which was loaded by the PLUGIN's ClassLoader
    private static Object leakedPlugin;   // <-- LEAK

    public void deploy(URLClassLoader pluginLoader) throws Exception {
        Class<?> clazz = pluginLoader.loadClass("com.example.Plugin");
        leakedPlugin = clazz.getDeclaredConstructor().newInstance();
        // pluginLoader can NEVER be collected while leakedPlugin is alive
        // All Plugin metadata stays in Metaspace FOREVER
    }
}

// Fixed: use weak reference or clear on undeploy
private static WeakReference<Object> safePlugin;

public void undeploy() {
    safePlugin = null;   // or leakedPlugin = null
    // Now the pluginLoader CAN be collected
}

// ── Diagnosing Metaspace leaks ────────────────────────────────────────
// 1. Watch Metaspace growth over redeployments:
//    jstat -gc <pid> 5000  (every 5 seconds)
//    Look for MC (Metaspace capacity) growing after each undeploy

// 2. Find retained ClassLoaders with heap dump:
//    jmap -dump:format=b,file=heap.hprof <pid>
//    Open in Eclipse MAT → OQL:
//    SELECT * FROM java.lang.ClassLoader

// 3. Identify ClassLoader retention path:
//    MAT → Find path from GC roots to each ClassLoader
//    The path shows what is holding the ClassLoader alive

// 4. jcmd output shows classloader stats:
//    jcmd <pid> VM.classloader_stats

// ── Recommended Metaspace JVM flags ──────────────────────────────────
// Development (allow growth, no limit):
// (no MaxMetaspaceSize — default unlimited)

// Production (bounded, monitored):
// java -XX:MaxMetaspaceSize=512m -XX:MetaspaceSize=128m MyApp

// Container/microservice (small footprint):
// java -XX:MaxMetaspaceSize=256m MyApp

// Application server with plugins (larger):
// java -XX:MaxMetaspaceSize=1g MyApp

// ── Diagnosing Metaspace OutOfMemoryError ─────────────────────────────
// java -XX:+HeapDumpOnOutOfMemoryError
//      -XX:HeapDumpPath=/dumps/
//      -XX:MaxMetaspaceSize=512m
//      -Xlog:class+load=info    ← log every class load
//      -Xlog:gc*                ← log GC including Metaspace
//      MyApp

// -Xlog:class+load output:
// [0.342s] Loaded com.example.UserService from file:/app/app.jar
// [0.343s] Loaded com.example.UserService$$SpringProxy$abc from null
// [1.234s] Loaded com.example.UserService from file:/app/app.jar  ← second load!
// ↑ Same class loaded twice = two ClassLoaders (possible leak)

// ── Monitoring Metaspace in production ───────────────────────────────
// Via JMX / Prometheus JMX exporter:
// java.lang:type=MemoryPool,name=Metaspace
//   .Usage.used      — current Metaspace bytes used
//   .Usage.committed — current allocated (may be higher than used)
//   .Usage.max       — MaxMetaspaceSize (-1 if unlimited)

// Key alert thresholds:
// Metaspace.used > 80% of MaxMetaspaceSize → WARNING
// Metaspace growth rate > 0 after warm-up → investigate ClassLoader leak

// ── Framework-specific Metaspace considerations ────────────────────────
// Spring Boot:
//   Each @Configuration class, @Bean, proxy generates 1-3+ Metaspace entries
//   Typical Spring app: 100-300MB Metaspace at startup
//   spring-boot-devtools: reloads classes → watch for accumulation

// CGLIB / ByteBuddy (Spring AOP, Mockito):
//   Each new proxy class = new entry in Metaspace
//   Mockito in tests: creates proxy per mock() call
//   Use @ExtendWith(MockitoExtension.class) to manage lifecycle

// Groovy / JRuby / dynamic languages embedded in JVM:
//   Scripts may generate a new class per eval — very high Metaspace growth
//   Reuse compiled scripts; avoid per-request compilation