import java.util.*;
 
/**
 * 模擬 Java 堆中的對(duì)象
 */
class HeapObject {
    private int id;       // 對(duì)象 ID
    private boolean alive; // 是否存活
 
    public HeapObject(int id) {
        this.id = id;
        this.alive = true; // 默認(rèn)存活
    }
 
    public int getId() {
        return id;
    }
 
    public boolean isAlive() {
        return alive;
    }
 
    public void setAlive(boolean alive) {
        this.alive = alive;
    }
}
 
/**
 * 模擬 Java 堆管理對(duì)象及垃圾回收
 */
class Heap {
    private List<HeapObject> objects = new ArrayList<>(); // 存儲(chǔ)所有對(duì)象
    private Set<HeapObject> roots = new HashSet<>(); // GC Roots（根對(duì)象）
 
    /**
     * 分配對(duì)象到堆中
     */
    public HeapObject allocateObject() {
        HeapObject obj = new HeapObject(objects.size() + 1);
        objects.add(obj);
        return obj;
    }
 
    /**
     * 將對(duì)象添加為 GC Root（防止回收）
     */
    public void addRootObject(HeapObject obj) {
        roots.add(obj);
    }
 
    /**
     * 移除 Root（模擬對(duì)象不再被引用）
     */
    public void removeRootObject(HeapObject obj) {
        roots.remove(obj);
    }
 
    /**
     * 運(yùn)行垃圾回收（標(biāo)記-清除）
     */
    public void runGarbageCollector() {
        System.out.println("========== 開(kāi)始垃圾回收 ==========");
        
        // 1. 標(biāo)記階段
        markPhase();
        
        // 2. 清除階段
        sweepPhase();
        
        // 3. 分配優(yōu)化（展示可復(fù)用空間）
        compactMemory();
 
        System.out.println("========== 垃圾回收完成 ==========");
    }
 
    /**
     * 標(biāo)記階段：標(biāo)記所有可達(dá)對(duì)象
     */
    private void markPhase() {
        System.out.println("[標(biāo)記階段] 識(shí)別存活對(duì)象...");
        for (HeapObject obj : objects) {
            obj.setAlive(false); // 初始設(shè)為未存活
        }
        for (HeapObject root : roots) {
            root.setAlive(true); // GC Roots 對(duì)象不會(huì)被回收
        }
    }
 
    /**
     * 清除階段：刪除未被標(biāo)記的對(duì)象
     */
    private void sweepPhase() {
        System.out.println("[清除階段] 釋放不可達(dá)對(duì)象...");
        Iterator<HeapObject> iterator = objects.iterator();
        while (iterator.hasNext()) {
            HeapObject obj = iterator.next();
            if (!obj.isAlive()) {
                System.out.println("對(duì)象 " + obj.getId() + " 被回收");
                iterator.remove();
            }
        }
    }
 
    /**
     * 內(nèi)存優(yōu)化：展示可復(fù)用的空間
     */
    private void compactMemory() {
        System.out.println("[分配優(yōu)化] 清理后可復(fù)用的對(duì)象空間：");
        for (HeapObject obj : objects) {
            System.out.println("對(duì)象 " + obj.getId() + " 仍然存活");
        }
    }
}
 
/**
 * 測(cè)試?yán)厥掌?
 */
public class GarbageCollectorDemo {
    public static void main(String[] args) {
        Heap heap = new Heap();
 
        // 分配對(duì)象
        HeapObject obj1 = heap.allocateObject();
        HeapObject obj2 = heap.allocateObject();
        HeapObject obj3 = heap.allocateObject();
        HeapObject obj4 = heap.allocateObject();
 
        // 設(shè)置 GC Root（模擬存活對(duì)象）
        heap.addRootObject(obj1);
        heap.addRootObject(obj3);
 
        // 運(yùn)行垃圾回收
        heap.runGarbageCollector();
 
        // 移除一個(gè) GC Root 并再次回收
        heap.removeRootObject(obj1);
        heap.runGarbageCollector();
    }
}