1
class RefCounted:
2
    """引用计数对象"""
3

4
    def __init__(self, value):
5
        self.value = value
6
        self.ref_count = 1
7
        self.references = []  # 引用的其他对象
8

9
    def add_ref(self):
10
        self.ref_count += 1
11

12
    def release(self):
13
        self.ref_count -= 1
14
        if self.ref_count == 0:
15
            # 递归释放引用的对象
16
            for obj in self.references:
17
                obj.release()
18
            self.free()
19

20
    def free(self):
21
        del self.value
22
        del self.references

1
# 循环引用问题
2
a = RefCounted("A")
3
b = RefCounted("B")
4
a.references.append(b)  # A → B, B.ref_count = 2
5
b.references.append(a)  # B → A, A.ref_count = 2
6

7
# 释放 a 和 b 的外部引用
8
a.release()  # A.ref_count = 1 (B 还引用 A)
9
b.release()  # B.ref_count = 1 (A 还引用 B)
10
# 内存泄漏！A 和 B 的计数都不为 0，但已不可达

1
class MarkSweepGC:
2
    """标记-清除垃圾回收器"""
3

4
    def __init__(self):
5
        self.heap = {}        # 对象 ID → 对象
6
        self.marked = set()   # 已标记的对象集合
7
        self.roots = []       # GC Roots
8

9
    def allocate(self, obj):
10
        """分配对象"""
11
        obj_id = id(obj)
12
        self.heap[obj_id] = obj
13
        return obj_id
14

15
    def collect(self):
16
        """执行垃圾回收"""
17
        # 阶段 1：标记
18
        self.marked = set()
19
        worklist = list(self.roots)
20

21
        while worklist:
22
            obj = worklist.pop()
23
            obj_id = id(obj)
24
            if obj_id not in self.marked:
25
                self.marked.add(obj_id)
26
                # 将引用的对象加入工作列表
27
                for ref in obj.get_references():
28
                    worklist.append(ref)
29

30
        # 阶段 2：清除
31
        unreachable = set(self.heap.keys()) - self.marked
32
        for obj_id in unreachable:
33
            del self.heap[obj_id]
34

35
        return len(unreachable)

1
class SemiSpaceGC:
2
    """半空间复制 GC（Cheney 算法）"""
3

4
    def __init__(self, size):
5
        self.from_space = bytearray(size)
6
        self.to_space = bytearray(size)
7
        self.size = size
8
        self.free_ptr = 0
9

10
    def collect(self, roots):
11
        """执行 GC"""
12
        self.free_ptr = 0
13
        scan_ptr = 0
14

15
        # 复制根对象到 To 空间
16
        for root in roots:
17
            root.forward = self._copy(root)
18

19
        # 扫描 To 空间中的对象
20
        while scan_ptr < self.free_ptr:
21
            obj = self._get_object(scan_ptr)
22
            for ref in obj.references:
23
                ref.forward = self._copy(ref)
24
            scan_ptr += obj.size
25

26
        # 交换 From 和 To 空间
27
        self.from_space, self.to_space = self.to_space, self.from_space
28

29
    def _copy(self, obj):
30
        """将对象复制到 To 空间"""
31
        if hasattr(obj, 'forward'):
32
            return obj.forward  # 已复制
33

34
        # 复制到 To 空间
35
        new_addr = self.free_ptr
36
        self._write_object(new_addr, obj)
37
        self.free_ptr += obj.size
38

39
        # 设置转发指针
40
        obj.forward = new_addr
41
        return new_addr

1
class WriteBarrier:
2
    """写屏障：记录跨代引用"""
3

4
    def __init__(self):
5
        self.remembered_set = set()  # 记忆集
6

7
    def write_ref(self, holder, field, new_ref):
8
        """对象引用更新时的写屏障"""
9
        field.__set__(holder, new_ref)
10

11
        # 如果老年代对象引用了年轻代对象
12
        if holder.generation == 'old' and new_ref.generation == 'young':
13
            self.remembered_set.add(holder)  # 记录跨代引用

1
# Dijkstra 写屏障（插入屏障）
2
# 新引用指向白色对象时，将白色对象标记为灰色
3
def dijkstra_write_barrier(holder, field, new_ref):
4
    if is_black(holder) and is_white(new_ref):
5
        mark_gray(new_ref)  # 将新引用标记为灰色
6
    field.__set__(holder, new_ref)
7

8
# Yuasa 写屏障（删除屏障）
9
# 删除旧引用时，将旧引用标记为灰色
10
def yuasa_write_barrier(holder, field, new_ref):
11
    old_ref = field.__get__(holder)
12
    if is_black(holder) and is_white(old_ref):
13
        mark_gray(old_ref)  # 将旧引用标记为灰色
14
    field.__set__(holder, new_ref)

1
class TriColorMarker:
2
    # 三色标记垃圾回收器
3

4
    def __init__(self):
5
        self.white = set()   # 未访问
6
        self.gray = set()    # 已发现，引用未扫描
7
        self.black = set()   # 已扫描完成
8
        self.roots = []
9

10
    def mark(self):
11
        # 初始化：所有对象为白色
12
        self.white = set(self.all_objects)
13
        self.gray = set()
14
        self.black = set()
15

16
        # 根对象标记为灰色
17
        for root in self.roots:
18
            self.white.discard(root)
19
            self.gray.add(root)
20

21
        # 处理灰色对象，直到灰色集合为空
22
        while self.gray:
23
            obj = self.gray.pop()
24
            for ref in obj.references:
25
                if ref in self.white:
26
                    self.white.discard(ref)
27
                    self.gray.add(ref)
28
            self.black.add(obj)
29

30
        # 此时白色对象就是垃圾
31
        return self.white

1
# 启用 GC 日志
2
java -Xlog:gc* -Xmx256m MyApp
3

4
# 使用不同 GC
5
java -XX:+UseG1GC -Xlog:gc MyApp       # G1
6
java -XX:+UseZGC -Xlog:gc MyApp         # ZGC（低延迟）
7
java -XX:+UseSerialGC -Xlog:gc MyApp    # Serial（单线程）

1
cat > gc_test.go << 'EOF'
2
package main
3
import (
4
    "fmt"
5
    "runtime"
6
    "time"
7
)
8
func main() {
9
    var stats runtime.MemStats
10
    for i := 0; i < 100; i++ {
11
        _ = make([]byte, 1024*1024)  // 分配 1MB
12
        runtime.ReadMemStats(&stats)
13
        fmt.Printf("Alloc: %d MB, NumGC: %d\n",
14
            stats.Alloc/1024/1024, stats.NumGC)
15
    }
16
}
17
EOF
18

19
GODEBUG=gctrace=1 go run gc_test.go

1
class SimpleGC:
2
    """简单的标记-清除 GC"""
3

4
    def __init__(self):
5
        self.objects = {}
6
        self.roots = set()
7

8
    def alloc(self, obj):
9
        oid = id(obj)
10
        self.objects[oid] = obj
11
        return oid
12

13
    def gc(self):
14
        marked = set()
15
        worklist = list(self.roots)
16

17
        while worklist:
18
            obj = worklist.pop()
19
            oid = id(obj)
20
            if oid in marked:
21
                continue
22
            marked.add(oid)
23
            for ref in getattr(obj, '_refs', []):
24
                worklist.append(ref)
25

26
        freed = 0
27
        for oid in list(self.objects.keys()):
28
            if oid not in marked:
29
                del self.objects[oid]
30
                freed += 1
31

32
        return freed