HikariTish

1
             ┌──────────────────────┐
2
             │   白色 (White)        │ ← 所有对象初始状态
3
             │   "潜在的垃圾"        │
4
             └──────────┬───────────┘
5
                        │ GC 从 Roots 发现它可达
6
                        ↓
7
             ┌──────────────────────┐
8
             │   灰色 (Grey)         │ ← 工作队列 / 波面
9
             │   "存活但未扫子节点"   │
10
             └──────────┬───────────┘
11
                        │ 扫描完子节点（所有引用）
12
                        ↓
13
             ┌──────────────────────┐
14
             │   黑色 (Black)        │ ← 确认存活
15
             │   "全部扫描完毕"      │
16
             └──────────────────────┘

1
步骤 1：初始化
2
    ┌──────────────────┐
3
    │ 所有对象 = 白色    │
4
    └────────┬─────────┘
5
             ↓
6
步骤 2：根节点扫描（Root Scanning）
7
    ┌──────────────────────────────┐
8
    │ 从 GC Roots 出发：           │
9
    │   - 全局变量                 │
10
    │   - 当前 Goroutine 栈上变量  │
11
    │   - 寄存器                   │
12
    │ 将 Roots 直接引用的对象 → 灰色 │
13
    └────────┬─────────────────────┘
14
             ↓
15
步骤 3：循环遍历（Tracing）──┐
16
    ┌──────────────────┐    │
17
    │ 从灰色集合取一对象  │    │
18
    │ 扫描其所有指针引用  │    │
19
    │ 白色子对象 → 灰色   │    │
20
    │ 自身 → 黑色        │────┘  重复直到灰色集合为空
21
    └──────────────────┘
22
             ↓
23
步骤 4：清扫（Sweep）
24
    ┌──────────────────┐
25
    │ 仍为白色 → 回收    │
26
    │ 黑色 → 重置为白色  │
27
    └──────────────────┘

1
时刻 T1：正常状态
2
    [黑色对象 A] ────指──→ [白色对象 C]
3
                              ↑
4
    [灰色对象 B] ──────指─────┘
5

6
时刻 T2：用户代码修改引用（同时满足两个条件）
7
    [黑色对象 A] ────指──→ [白色对象 C]   ← 条件一：黑色指向了白色
8

9
    [灰色对象 B]         (删除了指向 C 的指针)  ← 条件二：丢失了灰色引用
10

11
时刻 T3：GC 继续标记
12
    [黑色对象 A]（已扫描过，不会再扫描）
13
                              ↓
14
    [白色对象 C]  ← 彻底被"遗忘"！
15

16
结果：清扫阶段 → C 被回收 → 程序崩溃（A 还持有 C 的指针）

1
写屏障拦截：*slot = ptr
2

3
操作 1（删除写屏障思路）→ shade(oldPtr)：被删除的下游对象，标记为灰色
4
操作 2（插入写屏障思路）→ shade(ptr)：被添加的下游对象，标记为灰色

1
条件一（黑色指向白色）：
2
    → 插入写屏障：当黑色对象指向白色时，立即将白色染灰 → 条件一被破坏
3

4
条件二（灰色引用被删除）：
5
    → 删除写屏障：当灰色对象的引用被删除时，将被删除的对象染灰 → 条件二被破坏

1
机制 1：开局全变黑
2
    GC 开始时，一次性将当前所有 Goroutine 栈上的可达对象全部染成黑色
3

4
机制 2：新生命即黑色
5
    GC 期间，Goroutine 内部新创建的对象（如 subObj := &Struct{}）直接标记为黑色
6

7
机制 3：堆上严防死守
8
    所有堆上指针修改操作由写屏障拦截：
9
    - 断开引用 → 旧对象染灰
10
    - 建立引用 → 新对象染灰

1
白色对象能否在不惊动 GC 的情况下隐藏到黑色栈对象背后？
2

3
栈上对象：
4
    - 要么是 GC 开始时已扫描完的黑色对象（没有白色子对象）
5
    - 要么是 GC 期间新创建的黑色对象（新对象无历史引用）
6

7
堆上操作：
8
    - 任何堆指针的修改都被写屏障拦截
9
    - 被丢弃的旧引用 → 染灰（防止残留的白对象失去灰色上游）
10
    - 新加入的引用 → 染灰（防止被黑色对象直接指向）
11

12
结论：白色对象不可能"潜入"黑色栈对象的引用链中，因为所有通往堆的入口都被写屏障监控。

1
// src/runtime/mbarrier.go（简化表示）
2

3
// 假设用户代码要执行：*slot = ptr
4
// 编译器自动插入写屏障调用
5
func writeBarrier(slot *unsafe.Pointer, ptr unsafe.Pointer) {
6
    // 1. 获取当前 slot 中存储的旧指针值
7
    oldPtr := *slot
8

9
    // 2. 仅在 GC 标记阶段启用
10
    if gcphase == _GCmark {
11
        // shade(oldPtr): 将被覆盖的旧指针指向的对象染灰（删除写屏障思想）
12
        if oldPtr != nil {
13
            shade(oldPtr)
14
        }
15

16
        // shade(ptr): 将新指针指向的对象染灰（插入写屏障思想）
17
        if ptr != nil {
18
            shade(ptr)
19
        }
20
    }
21

22
    // 3. 执行真正的内存写入
23
    *slot = ptr
24
}

1
// src/runtime/mgcmark.go（逻辑示意）
2

3
// shade 将一个对象从白色或黑色标记为灰色
4
// 如果对象已经是灰色或黑色，则跳过
5
func shade(obj uintptr) {
6
    if obj == 0 {
7
        return
8
    }
9

10
    // 获取对象的 mark bits
11
    mbits := getMarkBits(obj)
12

13
    // 如果已经是黑色或灰色，跳过
14
    if mbits.isMarked() {
15
        return
16
    }
17

18
    // 标记为灰色并放入工作队列
19
    mbits.setMarked()
20
    gcw.put(obj)  // 放入灰色工作队列，等待后续扫描
21
}

1
// 栈上新创建对象的处理（编译期行为）
2

3
// 用户代码：subObj := &Struct{Field: value}
4
//
5
// 编译器生成代码（逻辑示意）：
6
//   subObj = stackalloc(sizeof(Struct))
7
//   subObj.Field = value
8
//   gcMarkBlack(subObj)  ← 直接标记为黑色，无屏障开销

1
┌─────────────────────────────────────────────────────────────────────┐
2
│                      GC 标记阶段完整流程                              │
3
├─────────────────────────────────────────────────────────────────────┤
4
│                                                                     │
5
│  1. STW 准备阶段（极短）                                              │
6
│     ├── 开启写屏障 (gcphase = _GCmark)                               │
7
│     ├── 统计 GC Roots                                                │
8
│     └── 扫描所有 Goroutine 栈 → 栈上对象全部染黑                       │
9
│                                                                     │
10
│  2. 并发标记阶段（用户代码继续运行）                                    │
11
│     ├── GC Worker 从灰色队列取对象，扫描其指针                          │
12
│     ├── 用户的堆指针操作被写屏障拦截                                    │
13
│     │     ├── *slot = ptr  → shade(oldPtr) + shade(ptr)              │
14
│     │     └── 栈上新建对象 → 直接染黑                                  │
15
│     └── 灰色队列为空时标记结束                                         │
16
│                                                                     │
17
│  3. STW 标记终止（极短）                                              │
18
│     ├── 关闭写屏障                                                    │
19
│     └── 检查灰色队列（确保完全为空）                                    │
20
│                                                                     │
21
│  4. 并发清扫（无需 STW）                                              │
22
│     ├── 白色对象 → 回收                                               │
23
│     └── 黑色对象 → 重置为白色（为下一轮 GC 准备）                        │
24
│                                                                     │
25
└─────────────────────────────────────────────────────────────────────┘

1
三色标记法（基础）
2
    │  问题：并发环境下的漏标
3
    ↓
4
插入写屏障（Go 早期）
5
    │  问题：堆上启效，栈不启效
6
    │  代价：标记结束需 STW 重扫栈（数百 ms）
7
    ↓
8
混合写屏障（Go 1.8+）
9
    │  核心：shade(被删旧引用) + shade(新加引用)
10
    │  关键优化：栈上对象直接黑色
11
    │  效果：标记结束无需 STW 重扫栈
12
    │  结果：STW 迈入亚毫秒级
13
    ↓
14
持续优化（Go 1.19+ GOMEMLIMIT 等）