快捷導(dǎo)航

Java實現(xiàn)基于清除后分配規(guī)則的垃圾回收器詳解

更新時間：2025年03月04日 08:34:48 作者：Katie。

垃圾回收是 Java 語言的一項重要特性,自動管理對象內(nèi)存,防止內(nèi)存泄漏和野指針問題,下面我們就來看看如何利用Java實現(xiàn)基于清除后分配規(guī)則的垃圾回收器吧

1. 項目介紹

垃圾回收（Garbage Collection，GC）是 Java 語言的一項重要特性，自動管理對象內(nèi)存，防止內(nèi)存泄漏和野指針問題。本項目的目標(biāo)是使用 Java 實現(xiàn)一個基于清除后分配規(guī)則（Mark-Sweep-Allocate）的垃圾回收器，模擬 Java 虛擬機（JVM）垃圾回收機制的基本過程。

項目功能

對象管理：在內(nèi)存堆中分配對象，并模擬對象的使用和釋放。

標(biāo)記階段（Mark）：識別仍在使用的對象。

清除階段（Sweep）：清理未被引用的對象，釋放空間。

分配策略（Allocate）：根據(jù)清理后的內(nèi)存布局，優(yōu)化新對象的分配。

2. 相關(guān)知識

在實現(xiàn)該項目之前，需要了解以下 Java 相關(guān)知識：

2.1 Java 內(nèi)存管理

Java 內(nèi)存通常分為以下幾個區(qū)域：

堆（Heap）：用于存儲對象，由 GC 進行自動管理。

棧（Stack）：用于存儲局部變量和方法調(diào)用。

方法區(qū)（Method Area）：存儲類元信息、靜態(tài)變量等。

2.2 標(biāo)記-清除算法（Mark-Sweep）

垃圾回收的標(biāo)記-清除算法包括兩個階段：

標(biāo)記階段（Mark）：

遍歷所有可達對象（從 GC Roots 開始，如靜態(tài)變量、棧變量）。
標(biāo)記仍然存活的對象。

清除階段（Sweep）：

清除未被標(biāo)記的對象，釋放空間。

2.3 分配策略

在清除后分配（Allocate）規(guī)則下，新的對象會優(yōu)先分配到已清理出的空閑內(nèi)存中，而不是直接擴展堆空間。這種策略減少了內(nèi)存碎片，提高了分配效率。

3. 項目實現(xiàn)思路

定義對象模型：

創(chuàng)建 HeapObject 類，模擬 Java 對象，包含對象 ID 和存活狀態(tài)。
創(chuàng)建 Heap 類，模擬 Java 堆，管理所有對象。

垃圾回收實現(xiàn)：

標(biāo)記階段：遍歷對象，標(biāo)記仍在使用的對象。
清除階段：清除未被標(biāo)記的對象，釋放空間。
分配規(guī)則：優(yōu)先復(fù)用清理出的空閑空間，優(yōu)化內(nèi)存管理。

模擬使用：

運行程序，動態(tài)分配對象并執(zhí)行 GC。
打印 GC 過程，觀察對象的回收情況。

4. 完整代碼（包含詳細注釋）

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);
    }
 
    /**
     * 運行垃圾回收（標(biāo)記-清除）
     */
    public void runGarbageCollector() {
        System.out.println("========== 開始垃圾回收 ==========");
        
        // 1. 標(biāo)記階段
        markPhase();
        
        // 2. 清除階段
        sweepPhase();
        
        // 3. 分配優(yōu)化（展示可復(fù)用空間）
        compactMemory();
 
        System.out.println("========== 垃圾回收完成 ==========");
    }
 
    /**
     * 標(biāo)記階段：標(biāo)記所有可達對象
     */
    private void markPhase() {
        System.out.println("[標(biāo)記階段] 識別存活對象...");
        for (HeapObject obj : objects) {
            obj.setAlive(false); // 初始設(shè)為未存活
        }
        for (HeapObject root : roots) {
            root.setAlive(true); // GC Roots 對象不會被回收
        }
    }
 
    /**
     * 清除階段：刪除未被標(biāo)記的對象
     */
    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();
            }
        }
    }
 
    /**
     * 內(nèi)存優(yōu)化：展示可復(fù)用的空間
     */
    private void compactMemory() {
        System.out.println("[分配優(yōu)化] 清理后可復(fù)用的對象空間：");
        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();
 
        // 設(shè)置 GC Root（模擬存活對象）
        heap.addRootObject(obj1);
        heap.addRootObject(obj3);
 
        // 運行垃圾回收
        heap.runGarbageCollector();
 
        // 移除一個 GC Root 并再次回收
        heap.removeRootObject(obj1);
        heap.runGarbageCollector();
    }
}