引用计数法 vs 可达性分析：两种判断算法对比

public class ReferenceCountingExample {
    public static void main(String[] args) {
        Object obj = new Object();  // ①
        Object ref1 = obj;          // ②
        Object ref2 = obj;          // ③
        ref1 = null;                // ④
        ref2 = null;                // ⑤
    }
}

// 伪代码
struct Object {
    int ref_count;  // 引用计数
    // 其他数据...
};

void addRef(Object* obj) {
    obj->ref_count++;
}

void removeRef(Object* obj) {
    obj->ref_count--;
    if (obj->ref_count == 0) {
        free(obj);  // 立即回收
    }
}

// 对象使用完毕后立即释放内存
{
    HugeObject obj = new HugeObject();  // 分配大对象
    obj.process();
}  // 块结束，obj计数为0，立即回收内存

public class CircularReference {
    public Object ref;

    public static void main(String[] args) {
        CircularReference obj1 = new CircularReference();
        CircularReference obj2 = new CircularReference();

        // 循环引用
        obj1.ref = obj2;
        obj2.ref = obj1;

        // 断开外部引用
        obj1 = null;
        obj2 = null;

        // 问题：obj1和obj2互相引用，计数都为1，无法回收
    }
}

for (int i = 0; i < 1000000; i++) {
    Object obj = new Object();  // 计数+1
    list.add(obj);              // 计数+1
}  // 每次循环都有2次计数更新

// 需要使用原子操作（CAS）保证线程安全
atomic_increment(&obj->ref_count);
atomic_decrement(&obj->ref_count);

class Node {
    public Node next;
}

Node node = new Node();
node.next = node;  // 自循环引用
node = null;       // 计数仍为1，无法回收

import sys

a = []
print(sys.getrefcount(a))  # 输出：2（a变量 + getrefcount临时引用）

b = a
print(sys.getrefcount(a))  # 输出：3（a变量 + b变量 + getrefcount临时引用）

# 循环引用
a.append(b)
b.append(a)
# Python使用额外的GC模块检测并回收循环引用

class Person {
    var name: String
    weak var friend: Person?  // weak避免循环引用
}

var p1: Person? = Person(name: "张三")
var p2: Person? = Person(name: "李四")

p1?.friend = p2
p2?.friend = p1  // weak引用，不增加计数

p1 = nil  // p1对象计数为0，被回收
p2 = nil  // p2对象计数为0，被回收

public void method() {
    Object localObj = new Object();  // GC Root（局部变量）
    // localObj是GC Root，只要方法未结束，对象就不会被回收
}

public class StaticReference {
    private static Object staticObj = new Object();  // GC Root（静态变量）

    public static void main(String[] args) {
        // staticObj始终可达，对象不会被回收
    }
}

public class ConstantReference {
    private static final Object CONSTANT = new Object();  // GC Root（常量）

    public static void main(String[] args) {
        // CONSTANT始终可达，对象不会被回收
    }
}

public class JNIReference {
    // Native方法引用的对象也是GC Root
    public native void nativeMethod();
}

public void synchronizedMethod() {
    Object lock = new Object();
    synchronized (lock) {
        // lock是GC Root（被synchronized持有）
        // 在同步块执行期间，lock不会被回收
    }
}

public class ReachabilityExample {
    private static Object staticObj = new Object();  // ① GC Root

    public static void main(String[] args) {
        Object obj1 = new Object();  // ② GC Root（局部变量）
        Object obj2 = new Object();  // ③ 通过obj1可达
        Object obj3 = new Object();  // ④ 不可达（垃圾）

        obj1.ref = obj2;  // obj1 → obj2

        // obj3没有任何引用链到达，是垃圾
    }
}

public class CircularReachability {
    public Object ref;

    public static void main(String[] args) {
        CircularReachability obj1 = new CircularReachability();
        CircularReachability obj2 = new CircularReachability();

        obj1.ref = obj2;  // obj1 → obj2
        obj2.ref = obj1;  // obj2 → obj1

        obj1 = null;
        obj2 = null;

        // 虽然obj1和obj2互相引用，但从GC Roots不可达
        // 两者都会被回收
    }
}

/**
 * VM参数：-Xms20M -Xmx20M -XX:+PrintGCDetails
 */
public class ReachabilityTest {
    private static final int _1MB = 1024 * 1024;

    public Object instance = null;

    public static void main(String[] args) {
        // 创建循环引用
        ReachabilityTest obj1 = new ReachabilityTest();
        ReachabilityTest obj2 = new ReachabilityTest();

        obj1.instance = obj2;
        obj2.instance = obj1;

        // 断开GC Roots引用
        obj1 = null;
        obj2 = null;

        // 建议GC
        System.gc();

        // 观察GC日志，obj1和obj2应该被回收
    }
}