垃圾回收——1960年，为什么让计算机自动释放内存，反而创造了更复杂的算法？

(A (B C) D)

class Node:
    def __init__(self, value, next=None):
        self.value = value
        self.next = next

(A B C)

root → A

objects = {
    "A": ["B"],
    "B": ["C"],
    "C": [],
    "D": ["E"],
    "E": ["D"],
    "F": [],
}

roots = ["A"]

def mark(objects, roots):
    reachable = set()
    stack = list(roots)

    while stack:
        node = stack.pop()

        if node in reachable:
            continue

        if node not in objects:
            continue

        reachable.add(node)
        stack.extend(objects[node])

    return reachable

def collect(objects, roots):
    reachable = mark(objects, roots)

    garbage = [
        node
        for node in objects
        if node not in reachable
    ]

    for node in garbage:
        del objects[node]

    return garbage

removed = collect(objects, roots)

print(removed)
# ['D', 'E', 'F']

print(objects)
# {'A': ['B'], 'B': ['C'], 'C': []}

a = SomeObject()
b = a

del a
del b

import gc

a = []
b = []

a.append(b)
b.append(a)

del a
del b

collected = gc.collect()

print("GC collected:", collected)

del a

#include <memory>

struct Node {
    int value;
};

int main() {
    auto p = std::make_unique<Node>();
    p->value = 100;
}

cache = []

def handle_request(request):
    result = {
        "request": request,
        "payload": "x" * 1_000_000,
    }

    cache.append(result)

gc.collect()