快捷導(dǎo)航

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

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

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

1. 項(xiàng)目介紹

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

項(xiàng)目功能

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

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

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

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

2. 相關(guān)知識(shí)

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

2.1 Java 內(nèi)存管理

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

堆（Heap）：用于存儲(chǔ)對(duì)象，由 GC 進(jìn)行自動(dòng)管理。

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

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

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

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

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

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

清除階段（Sweep）：

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

2.3 分配策略

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

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

定義對(duì)象模型：

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

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

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

模擬使用：

運(yùn)行程序，動(dòng)態(tài)分配對(duì)象并執(zhí)行 GC。
打印 GC 過(guò)程，觀察對(duì)象的回收情況。

4. 完整代碼（包含詳細(xì)注釋?zhuān)?/h2>

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();
    }
}