Golang如何实现指针引用计数

Go语言通过封装结构体模拟引用计数，使用sync.Mutex保护计数器，每次复制指针时调用IncRef增加引用，释放时调用DecRef减少，归零则触发cleanup回调，适用于管理CGO内存、文件句柄等需精确控制生命周期的资源，但需手动匹配增减引用以避免泄漏。

Go 语言本身不提供直接的引用计数机制，因为其内存管理依赖于垃圾回收器（GC），而不是像 C++ 那样手动管理引用。但如果你希望在 Go 中模拟指针的引用计数行为，比如追踪某个对象被多少个指针引用，可以通过封装结构体和使用 sync.WaitGroup 或 sync.Mutex 配合整型计数器来实现。

1. 使用引用计数结构体包装指针对象

核心思路是将原始数据包装在一个结构中，该结构包含一个引用计数和一个指向实际数据的指针。每次复制“指针”时增加计数，释放时减少计数，归零时可执行清理逻辑。

注意：这不是真正的指针引用计数，而是对共享数据的引用控制。

package main

import (
    "fmt"
    "sync"
)

type RefCounted struct {
    data interface{}
    refs int
    mu   sync.Mutex
    onZero func() // 引用归零时的回调，如释放资源
}

func NewRefCounted(data interface{}, cleanup func()) *RefCounted {
    return &RefCounted{
        data:   data,
        refs:   1,
        onZero: cleanup,
    }
}

// 增加引用
func (r *RefCounted) IncRef() *RefCounted {
    r.mu.Lock()
    r.refs++
    r.mu.Unlock()
    return r
}

// 减少引用
func (r *RefCounted) DecRef() {
    r.mu.Lock()
    r.refs--
    if r.refs == 0 {
        r.mu.Unlock()
        if r.onZero != nil {
            r.onZero()
        }
        return
    }
    r.mu.Unlock()
}

// 获取数据
func (r *RefCounted) Data() interface{} {
    r.mu.Lock()
    defer r.mu.Unlock()
    return r.data
}

2. 使用示例

下面是一个使用上述引用计数包装的例子：

func main() {
    cleanup := func() {
        fmt.Println("资源已被释放")
    }

    obj := NewRefCounted("共享字符串", cleanup)

    // 模拟多个引用
    ref1 := obj.IncRef()
    ref2 := obj.IncRef()

    // 使用数据
    fmt.Println("ref1 data:", ref1.Data())
    fmt.Println("ref2 data:", ref2.Data())

    // 释放引用
    obj.DecRef() // 总引用数: 2
    ref1.DecRef() // 总引用数: 1
    ref2.DecRef() // 总引用数: 0 → 触发 cleanup
}

输出：

ref1 data: 共享字符串
ref2 data: 共享字符串
资源已被释放

3. 实际应用场景与注意事项

这种模式适用于需要精确控制资源生命周期的场景，例如：

• 管理 CGO 分配的内存
• 共享大型缓存对象
• 文件句柄或网络连接的共享引用

重要提醒：

• Go 的 GC 不会感知你自定义的引用计数，因此必须确保每个 IncRef 都有对应的 DecRef，否则会内存泄漏。
• 避免循环引用，否则引用永远不为零。
• 并发访问需加锁（已通过 sync.Mutex 处理）。

基本上就这些。虽然 Go 不支持原生引用计数，但通过封装完全可以实现可控的引用行为。