Java实现基于清除后分配规则的垃圾回收器详解

import java.util.*;
 
/**
 * 模拟 Java 堆中的对象
 */
class HeapObject {
    private int id;       // 对象 ID
    private boolean alive; // 是否存活
 
    public HeapObject(int id) {
        this.id = id;
        this.alive = true; // 默认存活
    }
 
    public int getId() {
        return id;
    }
 
    public boolean isAlive() {
        return alive;
    }
 
    public void setAlive(boolean alive) {
        this.alive = alive;
    }
}
 
/**
 * 模拟 Java 堆管理对象及垃圾回收
 */
class Heap {
    private List<HeapObject> objects = new ArrayList<>(); // 存储所有对象
    private Set<HeapObject> roots = new HashSet<>(); // GC Roots（根对象）
 
    /**
     * 分配对象到堆中
     */
    public HeapObject allocateObject() {
        HeapObject obj = new HeapObject(objects.size() + 1);
        objects.add(obj);
        return obj;
    }
 
    /**
     * 将对象添加为 GC Root（防止回收）
     */
    public void addRootObject(HeapObject obj) {
        roots.add(obj);
    }
 
    /**
     * 移除 Root（模拟对象不再被引用）
     */
    public void removeRootObject(HeapObject obj) {
        roots.remove(obj);
    }
 
    /**
     * 运行垃圾回收（标记-清除）
     */
    public void runGarbageCollector() {
        System.out.println("========== 开始垃圾回收 ==========");
        
        // 1. 标记阶段
        markPhase();
        
        // 2. 清除阶段
        sweepPhase();
        
        // 3. 分配优化（展示可复用空间）
        compactMemory();
 
        System.out.println("========== 垃圾回收完成 ==========");
    }
 
    /**
     * 标记阶段：标记所有可达对象
     */
    private void markPhase() {
        System.out.println("[标记阶段] 识别存活对象...");
        for (HeapObject obj : objects) {
            obj.setAlive(false); // 初始设为未存活
        }
        for (HeapObject root : roots) {
            root.setAlive(true); // GC Roots 对象不会被回收
        }
    }
 
    /**
     * 清除阶段：删除未被标记的对象
     */
    private void sweepPhase() {
        System.out.println("[清除阶段] 释放不可达对象...");
        Iterator<HeapObject> iterator = objects.iterator();
        while (iterator.hasNext()) {
            HeapObject obj = iterator.next();
            if (!obj.isAlive()) {
                System.out.println("对象 " + obj.getId() + " 被回收");
                iterator.remove();
            }
        }
    }
 
    /**
     * 内存优化：展示可复用的空间
     */
    private void compactMemory() {
        System.out.println("[分配优化] 清理后可复用的对象空间：");
        for (HeapObject obj : objects) {
            System.out.println("对象 " + obj.getId() + " 仍然存活");
        }
    }
}
 
/**
 * 测试垃圾回收器
 */
public class GarbageCollectorDemo {
    public static void main(String[] args) {
        Heap heap = new Heap();
 
        // 分配对象
        HeapObject obj1 = heap.allocateObject();
        HeapObject obj2 = heap.allocateObject();
        HeapObject obj3 = heap.allocateObject();
        HeapObject obj4 = heap.allocateObject();
 
        // 设置 GC Root（模拟存活对象）
        heap.addRootObject(obj1);
        heap.addRootObject(obj3);
 
        // 运行垃圾回收
        heap.runGarbageCollector();
 
        // 移除一个 GC Root 并再次回收
        heap.removeRootObject(obj1);
        heap.runGarbageCollector();
    }
}