你成功了！如果你全部照做了，那你现在已经得到了一个简单的垃圾收集算法的句柄。如果你想看完整的代码，在这里。我再强调一点，尽管这个收集器很简单，但它可不是一个玩具。

你可以在这上面做一大堆的优化(像在GC和程序设计语言这些事情中，90%的努力都在优化上)，但它的核心代码可是真正的GC。它与目前Ruby和Lua中的收集器非常的相似。你可以使用一些类似的代码到你的项目中。去做些很酷的事情吧！

#include <stdio.h>
#include <stdlib.h>#define STACK_MAX 256typedef enum {OBJ_INT,OBJ_PAIR
} ObjectType;typedef struct sObject {ObjectType type;unsigned char marked;/* The next object in the linked list of heap allocated objects. */struct sObject* next;union {/* OBJ_INT */int value;/* OBJ_PAIR */struct {struct sObject* head;struct sObject* tail;};};
} Object;typedef struct {Object* stack[STACK_MAX];int stackSize;/* The first object in the linked list of all objects on the heap. */Object* firstObject;/* The total number of currently allocated objects. */int numObjects;/* The number of objects required to trigger a GC. */int maxObjects;
} VM;void assert(int condition, const char* message) {if (!condition) {printf("%s\n", message);exit(1);}
}VM* newVM() {VM* vm =(VM *) malloc(sizeof(VM));vm->stackSize = 0;vm->firstObject = NULL;vm->numObjects = 0;vm->maxObjects = 8;return vm;
}void push(VM* vm, Object* value) {assert(vm->stackSize < STACK_MAX, "Stack overflow!");vm->stack[vm->stackSize++] = value;
}Object* pop(VM* vm) {assert(vm->stackSize > 0, "Stack underflow!");return vm->stack[--vm->stackSize];
}void mark(Object* object) {/* If already marked, we're done. Check this first to avoid recursingon cycles in the object graph. */if (object->marked) return;object->marked = 1;if (object->type == OBJ_PAIR) {mark(object->head);mark(object->tail);}
}void markAll(VM* vm)
{for (int i = 0; i < vm->stackSize; i++) {mark(vm->stack[i]);}
}void sweep(VM* vm)
{Object** object = &vm->firstObject;while (*object) {if (!(*object)->marked) {/* This object wasn't reached, so remove it from the list and free it. */Object* unreached = *object;*object = unreached->next;free(unreached);vm->numObjects--;} else {/* This object was reached, so unmark it (for the next GC) and move on tothe next. */(*object)->marked = 0;object = &(*object)->next;}}
}void gc(VM* vm) {int numObjects = vm->numObjects;markAll(vm);sweep(vm);vm->maxObjects = vm->numObjects * 2;printf("Collected %d objects, %d remaining.\n", numObjects - vm->numObjects,vm->numObjects);
}Object* newObject(VM* vm, ObjectType type) {if (vm->numObjects == vm->maxObjects) gc(vm);Object* object = (Object *)malloc(sizeof(Object));object->type = type;object->next = vm->firstObject;vm->firstObject = object;object->marked = 0;vm->numObjects++;return object;
}void pushInt(VM* vm, int intValue) {Object* object = newObject(vm, OBJ_INT);object->value = intValue;push(vm, object);
}Object* pushPair(VM* vm) {Object* object = newObject(vm, OBJ_PAIR);object->tail = pop(vm);object->head = pop(vm);push(vm, object);return object;
}void objectPrint(Object* object) {switch (object->type) {case OBJ_INT:printf("%d", object->value);break;case OBJ_PAIR:printf("(");objectPrint(object->head);printf(", ");objectPrint(object->tail);printf(")");break;}
}void test1() {printf("Test 1: Objects on stack are preserved.\n");VM* vm = newVM();pushInt(vm, 1);pushInt(vm, 2);gc(vm);assert(vm->numObjects == 2, "Should have preserved objects.");
}void test2() {printf("Test 2: Unreached objects are collected.\n");VM* vm = newVM();pushInt(vm, 1);pushInt(vm, 2);pop(vm);pop(vm);gc(vm);assert(vm->numObjects == 0, "Should have collected objects.");
}void test3() {printf("Test 3: Reach nested objects.\n");VM* vm = newVM();pushInt(vm, 1);pushInt(vm, 2);pushPair(vm);pushInt(vm, 3);pushInt(vm, 4);pushPair(vm);pushPair(vm);gc(vm);assert(vm->numObjects == 7, "Should have reached objects.");
}void test4() {printf("Test 4: Handle cycles.\n");VM* vm = newVM();pushInt(vm, 1);pushInt(vm, 2);Object* a = pushPair(vm);pushInt(vm, 3);pushInt(vm, 4);Object* b = pushPair(vm);a->tail = b;b->tail = a;gc(vm);assert(vm->numObjects == 4, "Should have collected objects.");
}void perfTest() {printf("Performance Test.\n");VM* vm = newVM();for (int i = 0; i < 1000; i++) {for (int j = 0; j < 20; j++) {pushInt(vm, i);}for (int k = 0; k < 20; k++) {pop(vm);}}
}int main(int argc, const char * argv[]) {test1();test2();test3();test4();perfTest();return 0;
}

vm中有一个指针，指向最近加入的一个对象，需要注意的是，在没有gc之前，所有new的对象都由单链表相连，注意new的新对象的标志位为0

在vm中有一个栈，存储的是所有的局部变量，定义一个局部变量就压入栈中，离开了作用域就从栈中弹出

gc的过程是这样的，首先递归变量栈中的变量，并将其所指向的对象的标志位设为1，这样就能标志出所有还在使用中的对象，没有被遍历到的变量所指向的对象的标志位保持为0，

接着，通过vm中的那个指针，遍历所有的变量，如果标志位为1，则将其标志位设为0；如果标志位为0.，直接将其free，注意在free之前，要将其前一个对象的next执行其后一个对象。

https://github.com/munificent/mark-sweep

http://blog.jobbole.com/53376/