Golang中指针指向自身的应用与实现

Golang中指针指向自身的应用与实现 大家好

我有一个关于垃圾回收器的问题。

对于一种编程模式，我需要在结构体实例本身中存储一个指向该实例的指针。我的概念验证实现了我想要达到的目标，但我担心垃圾回收器会查看该实例，并发现即使引用是由实例本身持有的，仍然存在对它的引用。

我的担心是否正确，这会导致问题吗？还是垃圾回收器足够智能，能够识别出该引用不再需要？

2 回复

对象指向自身是没问题的。指向某个值的指针的存在并不足以让对象保持存活；该指针还必须能从根节点（例如直接或间接通过全局变量或函数局部变量）访问到。否则，为了清理任何内存，您都必须显式地将字段设置为 nil！

您可以有一对节点，每个节点都指向另一个节点，如果您有一个指针变量持有其中一个节点，那么两个节点都会在垃圾回收中“存活”。如果函数变量超出作用域，或被设置为其他指针值，那么这两个自引用的节点都将被回收（除非程序的其他地方持有指向这两个节点之一或两者的指针）：

package main

import "runtime"

type N struct {
    Next *N
    Value int
}

func main() {
    a := &N{Value: 1}
    b := &N{Value: 2}
    a.Next = b
    b.Next = a    // 使每个节点相互引用
    a = nil    // 这没问题，因为此函数调用
               // 仍然知道 `b`，并且 `b` 引用着
               // `a`。
    b = nil    // 现在除了 `a` 和 `b` 自身，
               // 没有其他东西引用 `a` 或 `b`。
               // 如果这些变量被释放，程序中的
               // 任何部分都不会受到影响，所以释放它们。
    runtime.GC()
    // 此时，`a` 和 `b` 都应该被释放，
    // 因为即使它们持有指向彼此的指针，
    // 这也是一个闭环，没有其他东西持有
    // 指针来保持它们存活。
}

更多关于Golang中指针指向自身的应用与实现的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go语言中，结构体持有指向自身的指针是完全安全的，不会导致垃圾回收问题。Go的垃圾回收器使用可达性分析算法，当外部不再引用该结构体实例时，即使内部有自引用指针，整个实例仍然会被正确回收。

以下是一个典型示例：

package main

import (
    "fmt"
    "runtime"
)

type SelfReferential struct {
    data int
    self *SelfReferential // 指向自身的指针
}

func createSelfRef() *SelfReferential {
    obj := &SelfReferential{data: 42}
    obj.self = obj // 设置自引用
    return obj
}

func main() {
    // 创建自引用结构体
    ref := createSelfRef()
    fmt.Printf("原始引用: %p, 自引用: %p\n", ref, ref.self)
    
    // 移除外部引用
    ref = nil
    
    // 建议垃圾回收
    runtime.GC()
    
    // 强制进行垃圾回收（仅用于演示）
    runtime.GC()
    
    fmt.Println("实例已被回收")
}

更复杂的场景如循环引用同样安全：

type Node struct {
    value int
    next  *Node
}

func createCycle() *Node {
    node1 := &Node{value: 1}
    node2 := &Node{value: 2}
    node3 := &Node{value: 3}
    
    node1.next = node2
    node2.next = node3
    node3.next = node1 // 形成循环引用
    
    return node1
}

func main() {
    head := createCycle()
    
    // 当head被置为nil时，整个循环引用链都会被回收
    head = nil
    runtime.GC()
}

Go的垃圾回收器能够正确处理：

  1. 自引用结构体
  2. 相互引用的结构体
  3. 复杂的循环引用链

只有当从根对象（全局变量、栈变量等）出发无法到达该实例时，才会被标记为可回收。内部的自引用指针不会阻止垃圾回收。

回到顶部