如何在 Go 指针与 uintptr 之间进行转换而不造成内存损坏？

Golang不知道大家是否熟悉？今天我将给大家介绍《如何在 Go 指针与 uintptr 之间进行转换而不造成内存损坏？》，这篇文章主要会讲到等等知识点，如果你在看完本篇文章后，有更好的建议或者发现哪里有问题，希望大家都能积极评论指出，谢谢！希望我们能一起加油进步！

指针之间的转换应使用 unsafe.pointer() 和 uintptr 进行。 我正在使用 go 编写一个解释器。这是非常简单的片段，使用 eid 结构在本机代码的不同部分之间携带对（类型，值）。这段代码令人惊讶，因为相同的 print 语句获得两个不同的值（请参阅 foo() 方法）。该对象被“封装”到 eid 中并转换回对象。

代码可以编译，但结果严重损坏。

如果你运行这个你会得到：

~/go%  go run testbug.go
create object 0xc000068e28 with class 0xc00000c060
here is y:0xc000068e28, y.isa: 0xc00000c060"
here is y:0xc000068e28, y.isa: 0x2c

package main

import (
    "fmt"
    "unsafe"
)

type EID struct {
    SORT *Class
    VAL  uintptr
}

// access to VAL
func OBJ(x EID) *Anything { return (*Anything)(unsafe.Pointer(x.VAL)) }
func INT(x EID) int       { return (int)((uintptr)(unsafe.Pointer(x.VAL))) }

// useful utility get the pointer as a uintptr
func (x *Anything) Uip() uintptr { return uintptr(unsafe.Pointer(x)) }

type Anything struct {
    Isa *Class
}

func (x *Anything) Id() *Anything { return x }

type Object struct {
    Anything
    name string
}

type Class struct {
    Object
    Super *Class
}

type Integer struct {
    Anything
    Value int
}

func MakeObject(c *Class) *Anything {
    o := new(Object)
    o.Isa = c
    return o.Id()
}

// this is the surprising example - EID is passed but the content is damaged
func (c *Class) Foo() EID {
    x := c.Bar()
    y := OBJ(x)
    z := y.Isa
    fmt.Printf("here is y:%p, y.Isa: %p\n", y, z)
    fmt.Printf("here is y:%p, y.Isa: %p\n", y, y.Isa)  // this produces a different value !
    return x
}

func (c *Class) Bar() EID {
    UU := EID{c, MakeObject(c).Uip()}
    fmt.Printf("create object %p with class %p\n", OBJ(UU), OBJ(UU).Isa)
    return UU
}

var aClass *Class
var aInteger *Class

func main() {
    aClass := new(Class)
    aClass.Isa = aClass
    aClass.Foo()
}

显然，指向指针的 uintptr 必须是本地的，并且不能发生在两个不同的地方（此处为 foo() 和 bar()）。我找到了解决方法，但我对这种奇怪的行为感到好奇。

正确答案

当您将指针（任何具体类型，甚至 unsafe.pointer 类型）存储到 uintptr 中时，这会向 go 的垃圾收集器隐藏指针。因此，如果没有其他指向它的指针，go可以自由地gc底层对象。

当您将 uintptr 转换为 unsafe.pointer 时，该对象（存储在 uintptr 中的值所转换的指针）需要存在。如果它被 gc 了，它就不再存在。因此，获取任何类型 *t 的某些指针值并将其存储在 uintptr 中的“安全”方法是将其存储在 unsafe.pointer 中。 unsafe.pointer 对象对于 go 的垃圾收集器来说是可见的，作为一个指针，因此这使实际对象保持活动状态。

您将在一些 go 内部软件中看到这种模式：

// need to keep the pointer alive while we make a syscall
p := unsafe.Pointer(foo)
ret := syscall.SyscallN(..., uintptr(foo), ...)

局部变量 p 的创建显然毫无意义，用于保护底层对象在操作系统系统调用读取其字节时不被 gc 回收。 （请注意，这与编译器过于友好，因为对 p 的赋值在这里似乎是死代码。也许内部软件比这更奇特，和/或他们使用 //go:... 注释为好吧。）

如果我采用你的非最小可重复示例并对它进行明显的最小更改，那么同样的模式在 go 演示中也适用。这是否足够（以及您希望如何在解释器中使用相同的概念）完全是另一个问题，但请参阅 playground copy。 注意：我必须向您的程序添加一个右大括号，但之后它表现出与您相同的行为锯; here's that version。它从 go vet 发出了两个关于滥用 unsafe.pointer 的警告，而我的更新版本则没有。

以上就是《如何在 Go 指针与 uintptr 之间进行转换而不造成内存损坏？》的详细内容，更多关于的资料请关注golang学习网公众号！