golang如何使用指针灵活操作内存？unsafe包原理解析

dz45693

已于 2024-06-22 22:01:32 修改

阅读量63

点赞数

文章标签： golang java 开发语言

于 2024-06-22 21:15:04 首次发布

原文链接：https://www.cnblogs.com/killianxu/p/18262567

版权

Hi 你好，我是k哥。一个大厂工作6年，还在继续搬砖的后端程序员。

我们都知道，C/C++提供了强大的万能指针void*，任何类型的指针都可以和万能指针相互转换。并且指针还可以进行加减等算数操作。那么在Golang中，是否有类似的功能呢？答案是有的，这就是我们今天要探讨的unsafe包。

本文将深入探讨unsafe包的功能和原理。同时，我们学习某种东西，一方面是为了实践运用，另一方面则是出于功利性面试的目的。所以，本文还会为大家介绍unsafe 包的典型应用以及高频面试题。

功能

为了实现灵活操作内存的目的，unsafe包主要提供了4个功能：

定义了Pointer类型，任何类型的指针都可和Pointer互相转换，类似于c语言中的void*

var a int = 1
p := unsafe.Pointer(&a) // 其它类型指针转Pointer
b := (*int)(p) // Pointer类型转其它类型指针
fmt.Println(*b) // 输出1

定义了uintptr类型，Pointer和uintptr可以互相转换， 从而实现指针的加减等算数运算。

type Person struct {
    age int
    name string
}
person := Person{age:18,name:"k哥"}
p := unsafe.Pointer(&person) // 其它类型指针转Pointer
u := uintptr(p) // Pointer类型转为uintptr
u=u+8 // uintptr加减操作
pName := unsafe.Pointer(u) // uintptr转换为Pointer
name := *(*string)(pName)
fmt.Println(name) // 输出k哥

uintptr是用于指针运算的，它只是一个存储一个 指针地址 的 int 类型，GC 不把 uintptr 当指针，因此， uintptr 类型的目标可能会被回收

获取任意类型内存对齐、偏移量和内存大小。

func Alignof(x ArbitraryType) uintptr // 内存对齐
func Offsetof(x ArbitraryType) uintptr // 内存偏移量
func Sizeof(x ArbitraryType) uintptr // 内存大小

Alignof 返回类型x的内存地址对齐值m，这个类型在内存中的地址必须是m的倍数(基于内存读写性能的考虑)。
Offsetof 返回结构体成员x在内存中的位置离结构体起始处(结构体的第一个字段的偏移量都是0)的字节数，即偏移量。
Sizeof 返回类型 x 所占据的字节数，如果类型x结构有指针，Sizeof不包含 x 指针成员所指向内容的大小。

ArbitraryType是占位符，golang编译器在编译时会替换为具体类型

高性能类型转换。

func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
func SliceData(slice []ArbitraryType) *ArbitraryType
func String(ptr *byte, len IntegerType) string 
func StringData(str string) *byte

Slice 传入任意类型的指针和长度，返回该类型slice变量
SliceData 传入任意类型的slice变量，返回该slice底层数组的指针。
String 从一个byte指针派生出一个指定长度的字符串。
StringData 用来获取一个字符串底层字节序列中的第一个byte的指针。

高性能类型转换原理

为什么说Slice、SliceData、String、StringData是高性能类型转换函数呢?下面我们就来剖析下它们的实现原理。

本文以String和StringData函数为例，Slice和SliceData函数实现原理类似。在介绍函数实现原理之前，先认识下string类型的底层数据结构StringHeader。string类型会被Golang编译器编译成此结构，其中Data是byte数组地址，Len是字符串长度。

type StringHeader struct {
        Data uintptr // byte数组地址
        Len  int // 字符串长度
}

String函数会被Go编译成下面的函数实现逻辑。我们可以发现，ptr指针转换为string类型，是直接将ptr赋值给StringHeader的成员Data，而不需要重新拷贝ptr指向的byte数组。从而通过零拷贝实现高性能类型转换。

import (
    "fmt"
    "reflect"
    "unsafe"
)

func String(ptr *byte, len int) string {
    p := (uintptr)(unsafe.Pointer(ptr))
    hdr := &reflect.StringHeader{
        Data: p,
        Len:  len,
    }
    // 将 StringHeader 转为 string
    str := *(*string)(unsafe.Pointer(hdr))
    return str
}

func main() {
    bytes := []byte{'h', 'e', 'l', 'l', 'o'}
    ptr := &bytes[0]
    len := 5
    str := String(ptr, len)
    fmt.Println(str) // 输出hello
}

StringData函数会被Go编译成下面的函数实现逻辑。同理，我们可以发现，string类型转换为byte，是直接取StringHeader的uintptr类型成员Data，并将其转换为byte。不需要拷贝整个string，重新生成byte数组。从而通过零拷贝实现高性能类型转换。

import (
    "fmt"
    "reflect"
    "unsafe"
)

func StringData(str string) *byte {
    hdr := (*reflect.StringHeader)(unsafe.Pointer(&str))
    data := hdr.Data
    return (*byte)(unsafe.Pointer(data))
}

func main() {
    str := "hello"
    data := StringData(str)
    fmt.Println(string(*data)) // 输出h
}

回到问题，为什么说Slice、SliceData、String、StringData是高性能类型转换函数呢？通过String和StringData函数的实现逻辑，我们可以知道，String和StringData利用unsafe包，通过零拷贝，实现了高性能类型转换。

典型应用

在实践中，常见使用unsafe包的场景有2个：

与操作系统以及非go编写(cgo)的代码通信。

func SetData(bytes []byte) { 
    cstr := (*C.char)(unsafe.Pointer(&bytes[0])) // 转换成一个C char类型
    C.setData(cstr, (C.int)(len(bytes))) // 调用C语言函数
}

高性能类型转换。

func Bytes2String(b []byte) string {
    return *(*string)(unsafe.Pointer(&b))
}

func String2Bytes(s string) []byte {
    sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
    bh := reflect.SliceHeader{
        Data: sh.Data,
        Len:  sh.Len,
        Cap:  sh.Len,
    }
    return *(*[]byte)(unsafe.Pointer(&bh))
}

高频面试题

能说说uintptr和unsafe.Pointer的区别吗？
字符串转成byte数组，会发生内存拷贝吗？

-------------------------------------------------------------------------------

Golang指针

*类型:普通指针类型，用于传递对象地址，不能进行指针运算。
unsafe.Pointer:通用指针类型，用于转换不同类型的指针，不能进行指针运算，不能读取内存存储的值（必须转换到某一类型的普通指针）。
uintptr:用于指针运算，GC 不把 uintptr 当指针，uintptr 无法持有对象。uintptr 类型的目标会被回收。

unsafe.Pointer 是桥梁，可以让任意类型的指针实现相互转换，也可以将任意类型的指针转换为 uintptr 进行指针运算。
unsafe.Pointer 不能参与指针运算，比如你要在某个指针地址上加上一个偏移量，Pointer是不能做这个运算的，那么谁可以呢?

就是uintptr类型了，只要将Pointer类型转换成uintptr类型，做完加减法后，转换成Pointer，通过*操作，取值，修改值，随意。

总结：unsafe.Pointer 可以让你的变量在不同的普通指针类型转来转去，也就是表示为任意可寻址的指针类型。而 uintptr 常用于与 unsafe.Pointer 打配合，用于做指针运算。

unsafe.Pointer

unsafe.Pointer称为通用指针，官方文档对该类型有四个重要描述：
（1）任何类型的指针都可以被转化为Pointer
（2）Pointer可以被转化为任何类型的指针
（3）uintptr可以被转化为Pointer
（4）Pointer可以被转化为uintptr
unsafe.Pointer是特别定义的一种指针类型（译注：类似C语言中的void类型的指针），在golang中是用于各种指针相互转换的桥梁，它可以包含任意类型变量的地址。
当然，我们不可以直接通过*p来获取unsafe.Pointer指针指向的真实变量的值，因为我们并不知道变量的具体类型。
和普通指针一样，unsafe.Pointer指针也是可以比较的，并且支持和nil常量比较判断是否为空指针。

一个unsafe.Pointer指针也可以被转化为uintptr类型，然后保存到指针型数值变量中（注：这只是和当前指针相同的一个数字值，并不是一个指针），然后用以做必要的指针数值运算。（uintptr是一个无符号的整型数，足以保存一个地址）**这种转换虽然也是可逆的，但是将uintptr转为unsafe.Pointer指针可能会破坏类型系统，因为并不是所有的数字都是有效的内存地址。

许多将unsafe.Pointer指针转为原生数字，然后再转回为unsafe.Pointer类型指针的操作也是不安全的。比如下面的例子需要将变量x的地址加上b字段地址偏移量转化为*int16类型指针，然后通过该指针更新x.b：

package main
 
import (
    "fmt"
    "unsafe"
)
 
func main() {
 
    var x struct {
        a bool
        b int16
        c []int
    }
 
    /**
    unsafe.Offsetof 函数的参数必须是一个字段 x.f, 然后返回 f 字段相对于 x 起始地址的偏移量, 包括可能的空洞.
    */
 
    /**
    uintptr(unsafe.Pointer(&x)) + unsafe.Offsetof(x.b)
    指针的运算
    */
    // 和 pb := &x.b 等价
    pb := (*int16)(unsafe.Pointer(uintptr(unsafe.Pointer(&x)) + unsafe.Offsetof(x.b)))
    *pb = 42
    fmt.Println(x.b) // "42"
}

上面的写法尽管很繁琐，但在这里并不是一件坏事，因为这些功能应该很谨慎地使用。不要试图引入一个uintptr类型的临时变量，因为它可能会破坏代码的安全性（注：这是真正可以体会unsafe包为何不安全的例子）。

下面段代码是错误的

// NOTE: subtly incorrect!
tmp := uintptr(unsafe.Pointer(&x)) + unsafe.Offsetof(x.b)
pb := (*int16)(unsafe.Pointer(tmp))
*pb = 42

　　产生错误的原因很微妙。**有时候垃圾回收器会移动一些变量以降低内存碎片等问题。这类垃圾回收器被称为移动GC。当一个变量被移动，所有的保存改变量旧地址的指针必须同时被更新为变量移动后的新地址。从垃圾收集器的视角来看，一个unsafe.Pointer是一个指向变量的指针，因此当变量被移动是对应的指针也必须被更新；但是uintptr类型的临时变量只是一个普通的数字，所以其值不应该被改变。上面错误的代码因为引入一个非指针的临时变量tmp，导致垃圾收集器无法正确识别这个是一个指向变量x的指针。当第二个语句执行时，变量x可能已经被转移，这时候临时变量tmp也就不再是现在的&x.b地址。**第三个向之前无效地址空间的赋值语句将彻底摧毁整个程序！

--------------------------------

package main

import (
	"fmt"
	"unsafe"
)

type user struct {
	id   int
	age  int
	name string
}

func main() {
	a := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	b := unsafe.Pointer(uintptr(unsafe.Pointer(&a[0])) + 9*unsafe.Sizeof(a[0]))

	// b是 unsafe.Pointer 所以可转任意指针，转成(*int)指针后在取值
	fmt.Printf("b: %v, unsafe.Sizeof(a[0]): %d\n", *(*int)(b), unsafe.Sizeof(a[0])) //b: 9, unsafe.Sizeof(a[0]): 8

	c := unsafe.Pointer(uintptr(unsafe.Pointer(&a)) + uintptr(16)) //int是8位长度 所以16 等于 16/8 挪动了2位，所以下面结果是2
	fmt.Printf("c: %v\n", *(*int)(c))                              //c: 2

	user := user{id: 1, age: 10, name: "user1"}
	namePointer := unsafe.Pointer(uintptr(unsafe.Pointer(&user)) + unsafe.Offsetof(user.name))

	//这也一样 name是 unsafe.Pointer 所以可转任意指针，转成(*string)指针后在取值
	fmt.Printf("name: %v\n", *(*string)(namePointer)) //name: user1
}

    //因slice的结构是 => |ptr|len|cap
    s := make([]int, 5, 10)
    var Len = *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(8))) //挪一个位置是Len
    fmt.Println(Len, len(s))                                                    // 5 5

    var Cap = *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(16))) //挪二个位置是CAP
    fmt.Println(Cap, cap(s))                                                     // 10 10

    mp := make(map[string]int)
    mp["a"] = 11
    mp["b"] = 22

    //因map结构中第一个是元素个数，所以可以直接转成len
    count := **(**int)(unsafe.Pointer(&mp))
    fmt.Println(count, len(mp)) // 2 2

--------------------------------------------------------

快速拷贝

如果两种类型的内存布局相同，为了避免内存分配，你可以通过以下机制将类型 *T1 的指针转换为类型 *T2 的指针，将类型 T1 的值复制到类型 T2 的变量中：

ptrT1 := &T1{}
ptrT2 = (*T2)(unsafe.Pointer(ptrT1))

但是要小心，这种转换是有代价的，现在两个指针指向同一个内存地址，所以每个指针的改变也会反应到另一个指针上。可以通过这里验证[1]。

unsafe.Pointer != uintptr

我已经提到过，指针可以转换为 uintptr 并转回来，但是转回来是有一些特殊的条件限制的。unsafe.Pointer 是一个真正的指针，它不仅保持内存地址，包括动态链接的地址，但 uintptr 只是一个数字，因此它更小，但有代价。如果你转换 unsafe.Pointer 为 uintptr 后，指针不再引用指向的变量，而且在将 uintptr 转换回 unsafe.Pointer 变量之前，垃圾收集器可以轻松地回收该内存。至少有两种解决方案可以避免此问题。第一个更复杂的，但也真正显示了，为了使用 unsafe 包，你必须牺牲什么。有一个特殊的函数，runtime.KeepAlive 可以避免 GC 不恰当的回收。它听起来很复杂，而且使用起来更加复杂。这里为你准备了实际例子[2]。

指针算法

还有另一种方法避免 GC 不恰当回收。即在同一个语句中做以下事情：将 unsafe.Poniter 转为 uintptr，以及将 uintptr 做其他运算，最后转回 unsafe.Pointer 。因为 uintptr 只是一个数字，我们可以做所有特殊的算术运算，比如加法或减法。我们如何使用它？指针算法通过了解内存布局和算术运算，可以得到任何需要的数据。让我们来看看下一个例子：

x := [4]byte{10, 11, 12, 13}
elPtr := unsafe.Pointer(uintptr(unsafe.Pointer(&x[0])) + 3*unsafe.Sizeof(x[0]))

有了指向字节数组第一个元素的指针，我们就可以在不使用索引的情况下获得最后一个元素。如果将指针移动三个字节，我们就可以得到最后一个元素。

因此，在一个表达式中执行所有转换可以省去 GC 清理的麻烦。上述三种模式说明了如何在不同情况下正确地转换 unsafe.Pointer 为其他数据类型的指针。

Syscalls

在包 syscall 中，有一个函数 syscall.Syscall 接收 uintptr 格式的指针的系统调用，我们可以通过 unsafe.Pointer 得到 uintptr。重要的是，你必须进行正确的转换：

a := &A{1}
b := &A{2}
syscall.Syscall(0, uintptr(unsafe.Pointer(a)), uintptr(unsafe.Pointer(b))) // Right
 
aPtr := uintptr(unsafe.Pointer(a)
bPtr := uintptr(unsafe.Pointer(b)
syscall.Syscall(0, aPtr, bPtr) // Wrong

reflect.Value.Pointer 和 reflect.Value.UnsafeAddr

reflect 包中有两个方法: Pointer 和 UnsafeAddr，它们返回 uintptr，因此我们应该立即将结果转换为 unsafe.Pointer，因为我们需要时刻“提防”我们的 GC 朋友：

p1 := (*int)(unsafe.Pointer(reflect.ValueOf(new(int)).Pointer())) // Right
 
ptr := reflect.ValueOf(new(int)).Pointer() // Wrong
p2 := (*int)(unsafe.Pointer(ptr) // Wrong

reflect.SliceHeader 和 reflect.StringHeader

reflect 包中有两种类型: SliceHeader 和 StringHeader，它们都具有字段 Data uintptr。正如你所记得的那样，uintptr 通常与 unsafe.Pointer 联系在一起，见下面代码：

var s string
hdr := (*reflect.StringHeader)(unsafe.Pointer(&s))
hdr.Data = uintptr(unsafe.Pointer(p))
hdr.Len = n

dz45693

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
golang如何使用指针灵活操作内存？unsafe包原理解析

Hi 你好，我是k哥。一个大厂工作6年，还在继续搬砖的后端程序员。我们都知道，C/C++提供了强大的万能指针void*，任何类型的指针都可以和万能指针相互转换。并且指针还可以进行加减等算数操作。那么在Golang中，是否有类似的功能呢？答案是有的，这就是我们今天要探讨的unsafe包。本文将深入探讨unsafe包的功能和原理。同时，我们学习某种东西，一方面是为了实践运用，另一方面则是出于功利性面试的目的。所以，本文还会为大家介绍unsafe 包的典型应用以及高频面试题。
复制链接

扫一扫