How does generational collection work in Java memory management?

Generational collection is a Java memory management technology that divides heap memory into different areas (generations) to optimize memory management of different object life cycles. The process includes: marking unreachable objects; clearing marked objects and releasing memory; moving surviving objects and optimizing memory layout.

Generational collection in Java memory management

In the Java Virtual Machine (JVM), generational collection is a A memory management technology that divides heap memory into different regions (called generations), each optimized for a different object life cycle.

The purpose of generational collection is to optimize memory management and reduce application pause time and garbage collection overhead. It does this by classifying objects by life cycle:

Young generation:

• Stores short-lived objects.
• Frequent garbage collection to remove unreachable objects.

Old generation:

• Storage long-term surviving objects.
• Do garbage collection less frequently because most objects will live longer.

Persistent generation:

• Stores persistent metadata and class information.
• Garbage collection is rarely done.

The process of generational collection:

1. Marking: The garbage collector marks unreachable objects.
2. Clear: The garbage collector clears marked objects and releases their memory.
3. Compaction: The garbage collector moves surviving objects to adjacent memory blocks, leaving a compact memory layout.

Practical case:

The following Java code demonstrates how generational collection affects the life cycle of an object:

public class GenerationSample {

    public static void main(String[] args) {
        // 创建一个短期存活的对象
        Object shortLivedObject = new Object();

        // 创建一个长期存活的对象
        Object longLivedObject = new Object();

        // 保留对长期存活对象的引用，防止它被垃圾回收
        longLivedObject = null;

        // 触发垃圾回收
        System.gc();

        // 检查短期存活对象是否已被清除
        if (!isReachable(shortLivedObject)) {
            System.out.println("短期存活对象已清除");
        }

        // 检查长期存活对象是否仍然存活
        if (isReachable(longLivedObject)) {
            System.out.println("长期存活对象仍然存活");
        }
    }

    private static boolean isReachable(Object object) {
        try {
            return new java.lang.ref.WeakReference<>(object).get() != null;
        } catch (Exception e) {
            return false;
        }
    }
}

In this example , shortLivedObject will be allocated to the young generation, and longLivedObject will be allocated to the old generation. Since longLivedObject is retained as a reference, it will survive until garbage collection. And shortLivedObject will most likely be cleared since it is unreachable in the young generation.

The above is the detailed content of How does generational collection work in Java memory management?. For more information, please follow other related articles on the PHP Chinese website!