Go weak.Pointer 怎么实现不阻止回收的对象索引

要做一个“不阻止对象回收”的对象索引，核心不是把普通指针藏进 map，而是让索引只保存 weak.Pointer[T]：业务调用方继续持有强指针时，索引可以取回对象；当对象只剩弱引用时，垃圾回收器可以回收它，下一次 Value() 可能得到 nil。

官方文档：https://pkg.go.dev/weak

可靠的做法是“强引用负责对象生命周期，弱索引负责尝试查找”。不要把 weak.Pointer 当成一定能取回对象的句柄，也不要依赖某一次 GC 立即发生来完成业务逻辑。

先把索引和对象的所有权分开

假设程序按文档 ID 管理一批昂贵对象。真正使用对象的请求会保存 *Document，而全局索引只希望复用仍在使用的对象，不希望因为索引的存在让所有文档永久存活。这个关系可以画成两条边：

• 业务变量到 *Document 是强引用，决定对象当前是否可达。
• 索引键到 weak.Pointer[Document] 是弱引用，只提供一次查找机会。

这类索引适合对象缓存、规范化表或临时关联表，不适合存放必须长期存在的配置、订单状态和权限数据。后者应该用普通强引用、数据库或其他明确的持久化边界。

用 weak.Make 写一个泛型弱索引

下面的实现把并发保护、弱引用创建和失效条目删除放进一个小类型中。Get 先在读锁下取出弱指针并调用 Value；若对象已经不可达，再用写锁删除，但只删除仍等于刚才观察到的那一个弱指针，避免覆盖并发写入的新对象。

package weakindex

import (
    "sync"
    "weak"
)

type Index[K comparable, V any] struct {
    mu     sync.RWMutex
    values map[K]weak.Pointer[V]
}

func New[K comparable, V any]() *Index[K, V] {
    // 索引只保存 weak.Pointer，不保存 *V，避免索引延长对象生命周期。
    return &Index[K, V]{values: make(map[K]weak.Pointer[V])}
}

func (x *Index[K, V]) Put(key K, value *V) {
    x.mu.Lock()
    defer x.mu.Unlock()
    // value 的强引用由调用方保留；这里仅建立弱引用。
    x.values[key] = weak.Make(value)
}

func (x *Index[K, V]) Get(key K) (*V, bool) {
    x.mu.RLock()
    p, ok := x.values[key]
    if !ok {
        x.mu.RUnlock()
        return nil, false
    }
    value := p.Value()
    x.mu.RUnlock()
    if value != nil {
        return value, true
    }

    x.mu.Lock()
    // 只删除自己观察到的旧值，避免误删并发 Put 写入的新对象。
    if current, exists := x.values[key]; exists && current == p {
        delete(x.values, key)
    }
    x.mu.Unlock()
    return nil, false
}

这里的 Get 返回 *V 后，调用方在使用期间已经拿到了强引用；如果返回 nil，说明这次索引命中已经失效。代码不把失效当异常，而是把它当作一次正常的缓存未命中。

Value 返回 nil 时怎样避免误删

weak.Pointer 是可比较的，而且它的身份独立于所指对象是否已经被回收。因此，清理失效项时不能只按键名无条件 delete。如果另一个 goroutine 刚好用同一个键写入新对象，无条件删除会把新条目一起删掉。

不要用“调用 runtime.GC 后一定是 nil”来写测试。官方文档明确说明，Value 何时返回 nil 受对象可达性、终结器和分配批处理等因素影响；弱指针提供的是不阻止回收的语义，不是确定的回收通知。

需要主动删键时再考虑 AddCleanup

只用弱指针，索引键可能会在对象回收后保留一段时间，直到下一次查找把它清走。如果键很多，可以把 runtime.AddCleanup 作为加速清理的手段，但要特别检查闭包捕获：cleanup 函数和它的参数都不能重新持有被观察对象，否则对象仍然可达，清理就可能永远不发生。

func (x *Index[K, V]) PutWithCleanup(key K, value *V) {
    x.mu.Lock()
    p := weak.Make(value)
    x.values[key] = p
    x.mu.Unlock()

    // cleanup 只接收 key 和弱指针，不捕获 value 这个强引用。
    runtime.AddCleanup(value, func(k K) {
        x.mu.Lock()
        defer x.mu.Unlock()
        if current, ok := x.values[k]; ok && current == p {
            delete(x.values, k)
        }
    }, key)
}

这个扩展需要在导入列表中加入 runtime，并且生产代码要明确索引实例的并发和销毁边界。cleanup 是非确定性的，不能替代 Get 中的失效检查；它只是让过期键更有机会被主动移除。

按这五项验收实现

1. 索引结构中没有 *V、闭包捕获的 value 或把对象放进 cleanup 参数的字段。
2. 所有跨 goroutine 的访问都通过同一把锁保护，失效删除会比较旧弱指针。
3. 调用方在需要对象的整个使用区间保留强指针；必要时在最后一次使用后调用 runtime.KeepAlive。
4. 测试只验证“索引不阻止回收”和“nil 可被当作未命中”，不把 GC 时序写成固定断言。
5. 必须长期可靠的数据不放在弱索引中，缓存重建失败时有明确的回源或报错方案。

简而言之，weak.Pointer 让索引观察对象而不拥有对象。把生命周期交给强引用，把查找和失效清理由索引负责，才能既减少长期缓存占用，又不把非确定性的垃圾回收过程误当成业务状态机。

相关问题

weak.Pointer.Value 为什么可能一直不是 nil？对象可能仍然可达，也可能与同一分配批次中的其他小对象共享空间；文档不保证某个时刻一定变成 nil。

weak.Pointer 能当 map 的 key 吗？它是可比较的，但是否适合作为键要看键和值是否会反向强引用对象；设计不当仍会让对象保持存活。

普通缓存应该默认使用 weak.Pointer 吗？不应该。只有缓存条目可以随时重建、且索引不应拥有对象时才考虑它，普通热点缓存通常需要明确的淘汰策略。