What is metaspace in Java? How does it differ from PermGen space?

Prior to Java 8, the JVM had a permanent generation (PermGen) space for storing metadata, such as class definitions and method information. However, starting from Java 8, PermGen space has been removed and replaced with a new Metaspace.

Metaspace is a memory space in the JVM used to store class metadata, such as the names of classes and methods, and the fields used by them. It is not part of the heap and is allocated from native memory. This means that it is not subject to the same limitations as the heap space and can grow dynamically as needed.

One key advantage of using Metaspace is that it eliminates the need to manually tune the size of the PermGen space. In the PermGen space, if the amount of metadata increased, the space had to be increased manually, which could lead to OutOfMemory errors if the space was not large enough.

Metaspace also provides better performance and scalability compared to the PermGen space. In the PermGen space, garbage collection had to be manually triggered, which could lead to performance issues if the space was not correctly sized. With Metaspace, garbage collection is automatic and scalable.

Here is an example code snippet showing how to use Metaspace:

import java.util.ArrayList;
import java.util.List;

public class MetaspaceExample {
   public static void main(String[] args) {
      List<Class<?>> classList = new ArrayList<>();
      while (true) {
         Class<?> dynamicClass = MetaspaceGenerator.generateClass();
         classList.add(dynamicClass);
      }
   }
}

class MetaspaceGenerator {
   private static int counter = 0;

   public static synchronized Class<?> generateClass() {
      String className = "DynamicClass" + counter++;
      String classContent = "public class " + className + " {}";
      byte[] byteCode = classContent.getBytes();

      return ClassLoader.defineClass(className, byteCode, 0, byteCode.length);
   }
}

In this example, the MetaspaceExample class creates a list of dynamically generated classes by calling the MetaspaceGenerator.generateClass() method in an infinite loop. The MetaspaceGenerator class generates a new class with a unique name every time the generateClass() method is called, and returns the corresponding Class object. The defineClass() method of the ClassLoader class is used to load the generated class into the Metaspace. Since Metaspace is automatically garbage collected, the dynamically generated classes will be removed from memory when they are no longer needed, without requiring any manual intervention.