详解如何使用unsafe标准库突破Golang中的类型限制_Golang

1 简介

在使用c语言编程时，常常因为类型的问题大伤脑筋，而其他语言比如java，python默认类型又是难以改变的，golang提供了一些方式用于喜欢hack的用户。

2 标准库unsafe的简单介绍

官方说明标准库 unsafe 包含绕过 go 程序的类型安全的操作。

导入unsafe包可能是不可移植的，并且不受 go 1 兼容性指南的保护。

在1.20中，标准库的unsafe包很小, 二个结构体类型，八个函数，在一个文件中。

package unsage

    type arbitrarytype int
    type integertype int
    type pointer *arbitrarytype

    func sizeof(x arbitrarytype) uintptr
    func offsetof(x arbitrarytype) uintptr
    func alignof(x arbitrarytype) uintptr

    func add(ptr pointer, len integertype) pointer
    func slice(ptr *arbitrarytype, len integertype) []arbitrarytype
    func slicedata(slice []arbitrarytype) *arbitrarytype
    func string(ptr *byte, len integertype) string
    func stringdata(str string) *byte

unsafe包定义了二个类型和八个函数，二个类型 arbitrarytype 和 integertype 不真正属于unsafe包，我们在go代码中并不能使用它们定义变量。

它表示一个任意表达式的类型，仅用于文档目的，go编译器会对其做特殊处理。

虽然位于 unsafe，但是 alignof，offsetof，sizeof，这三个函数的使用是绝对安全的。以至于go设计者rob pike提议移走它们。

这三个函数的共同点是都返回 uintptr 类型。

之所以使用 uintptr 类型而不是 uint64 整型，因为这三个函数更多应用于有 unsafe.pointer和 uintptr类型参数的指针运算。

采用uintptr做为返回值类型可以减少指针运算表达式的显式类型转换。

2.1 获取大小 sizeof

sizeof 用于获取一个表达式的大小。该函数获取一个任意类型的表达式 x，并返回按bytes计算的大小，假设变量v，并且v通过 v =x声明。

sizeof 接收任何类型的表达式x，并返回以bytes字节为单位的大小，并且假设变量v是通过var v = x声明的。该大小不包括任何可能被x引用的内存。

例如，如果x是一个切片，sizeof返回切片描述符的大小，而不是该片所引用的内存的大小。
对于一个结构体，其大小包括由字段对齐引入的任何填充。

如果参数x的类型没有变化，不具有可变的大小，sizeof的返回值是一个go常数不可变值。
（如果一个类型是一个类型参数，或者是一个数组，则该类型具有可变的大小或结构类型中的元素大小可变）。

示例：

var (
        i  int = 5
        a      = [10]int{}
        ss     = a[:]
        f  funcfoo

        prevalue = map[string]uintptr{
            "i":       8,
            "a":       80,
            "ss":      24,
            "f":       48,
            "f.c":     10,
            "int_nil": 8,
        }
    )

    type funcfoo struct {
        a int
        b string
        c [10]byte
        d float64
    }
    func testfuncsizeof(t *testing.t) {
        defer setup(t.name())()
        fmt.printf("\texecute test:%v\n", t.name())

        if unsafe.sizeof(i) != prevalue["i"] {
            errorhandler(fmt.sprintf("size: %v not equal %v", unsafe.sizeof(i), prevalue["i"]), t)
        }

        if unsafe.sizeof(a) != prevalue["a"] {
            errorhandler(fmt.sprintf("size: %v not equal %v", unsafe.sizeof(i), prevalue["a"]), t)

        }

        if unsafe.sizeof(ss) != prevalue["ss"] {
            errorhandler(fmt.sprintf("size: %v not equal %v", unsafe.sizeof(i), prevalue["ss"]), t)

        }
        if unsafe.sizeof(f) != prevalue["f"] {
            errorhandler(fmt.sprintf("size: %v not equal %v", unsafe.sizeof(i), prevalue["f"]), t)

        }
        if unsafe.sizeof(f.c) != prevalue["f.c"] {
            errorhandler(fmt.sprintf("size: %v not equal %v", unsafe.sizeof(i), prevalue["f.c"]), t)

        }
        if unsafe.sizeof(unsafe.sizeof((*int)(nil))) != prevalue["int_nil"] {
            errorhandler(fmt.sprintf("size: %v not equal %v", unsafe.sizeof(i), prevalue["int_nil"]), t)

        }
    }

sizeof 函数不支持之间传入无类型信息的nil值，如下错误

unsafe.sizeof(nil)

我们必须显式告知 sizeof 传入的nil究竟是那个类型，

unsafe.sizeof(unsafe.sizeof((*int)(nil)))

必须显式告知nil是哪个类型的nil，这就是传入一个值 nil 但是类型明确的变量。

对齐系数 alignof 用于获取一个表达式的内地地址对齐系数，对齐系数 alignment factor 是一个计算机体系架构 computer architecture 层面的术语。

在不同计算机体系中，处理器对变量地址都有对齐要求，即变量的地址必须可被该变量的对齐系数整除。

它接收一个任何类型的表达式x，并返回所需的排列方式假设变量v是通过var v = x声明的。
它是m一个最大的值。

例1，

a      = [10]int{}

        reflect.typeof(x).align()  //8
        unsafe.alignof(a)   //8

它与reflect.typeof(x).align()返回的值相同。

作为一个特例，如果一个变量s是结构类型，f是一个字段，那么alignof(s.f)将返回所需的对齐方式。

该类型的字段在结构中的位置。这种情况与reeflect.typeof(s.f).fieldalign()返回的值。

alignof的返回值是一个go常数，如果参数的类型不具有可变大小。
（关于可变大小类型的定义，请参见[sizeof]的描述）。

继上例2：

var (
        i  int = 5
        a      = [10]int{}
        ss     = a[:]
        f  funcfoo
        zhs = "文"

        prevalue = map[string]uintptr{
            "i":       8,
            "a":       80,
            "ss":      24,
            "f":       48,
            "f.c":     10,
            "int_nil": 8,
        }
    )

    func testalignof(t *testing.t) {

        defer setup(t.name())()
        fmt.printf("\texecute test:%v\n", t.name())

        var x int 

        b := uintptr(unsafe.pointer(&x))%unsafe.alignof(x) == 0
        t.log("alignof:", b)

        if unsafe.alignof(i) != prevalue["i"] {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), prevalue["int_nil"]), t)

        }

        if unsafe.alignof(a) != prevalue["i"] {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), prevalue["int_nil"]), t)

        }

        if unsafe.alignof(ss) != prevalue["i"] {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), prevalue["int_nil"]), t)

        }

        if unsafe.alignof(f.a) != prevalue["i"] {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), prevalue["int_nil"]), t)

        }

        if unsafe.alignof(f) != prevalue["i"] {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), prevalue["int_nil"]), t)

        }

中文对齐系数为 8

if unsafe.alignof(zhs) != prevalue["i"] {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), prevalue["i"]), t)
        }

空结构体对齐系数 1

if unsafe.alignof(struct{}{}) != 1 {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), 1), t)
        }

byte 数组对齐系数为 1

if unsafe.alignof(sbyte) != 1 {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), 1), t)
        }

长度为0 的数组，与其元素的对齐系数相同

if unsafe.alignof([0]int{}) != 8 {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), 8), t)
        }

长度为0 的数组，与其元素的对齐系数相同

if unsafe.alignof([0]struct{}{}) != 1 {
            errorhandler(fmt.sprintf("alignof: %v not equal %v", unsafe.sizeof(i), 1), t)
        }

    }

执行它：

go test -timeout 30s -run ^testalignof$ ./unsafe_case.go

对齐系数 alignment factor，变量的地址必须可被该变量的对齐系数整除。

2.2 使用对齐的例子

我们使用相同字段，分别创建两个结构体属性分别为对齐或不对齐，帮助 go 更好地分配内存和使用cpu读取，查看效果

type randomresource struct {
        cloud               string // 16 bytes
        name                string // 16 bytes
        havedsl             bool   //  1 byte
        pluginversion       string // 16 bytes
        isversioncontrolled bool   //  1 byte
        terraformversion    string // 16 bytes
        moduleversionmajor  int32  //  4 bytes
    }

    type orderresource struct {
        moduleversionmajor  int32  //  4 bytes
        havedsl             bool   //  1 byte
        isversioncontrolled bool   //  1 byte
        cloud               string // 16 bytes
        name                string // 16 bytes
        pluginversion       string // 16 bytes
        terraformversion    string // 16 bytes

    }

字段存储使用的空间与字段值没有关系

var d randomresource
         d.cloud = "aws-singapore"
         ...

         infohandler(fmt.sprintf("随机顺序属性的结构体内存 总共占用 structtype: %t => [%d]\n", d, unsafe.sizeof(d)), m)
         var te = orderresource{}
         te.cloud = "aws-singapore"  
         ...
         m.logf("属性对齐的结构体内存 总共占用  structtype:d %t => [%d]\n", te, unsafe.sizeof(te))

然后复制结构体，并改变其属性值，查看存储空间和值的长度变化

te2 := te
        te2.cloud = "ali2"
        m.logf("结构体2 te2:%#v\n", &te2)
        m.logf("结构体1 te:%#v\n", &te)

        m.log("改变 te3 将同时改变 te,te3 指向了 te的地址")
        m.log("复制了对齐结构体，并重新赋值，用于查看字段长度。")
        m.log("(*te).cloud:", (te).cloud, "*te.cloud", te.cloud, "te size:", unsafe.sizeof(te.cloud), "te value len:", len(te.cloud))

        te3 := &te
        te3.cloud = "hwcloud2"

        m.log("(*te3).cloud:", (*te3).cloud, "*te3.cloud", te3.cloud, "te3 size:", unsafe.sizeof(te3.cloud), "te3 value len:", len(te3.cloud))
        m.logf("字段 cloud:%v te3:%p\n", (*te3).cloud, te3)
        m.logf("字段 cloud:%v order:%v te:%v, addr:%p\n", te.cloud, (te).cloud, te, &te)

执行它，

go test -v .\case_test.go

得到以下输出:

随机顺序属性的结构体内存总共占用 structtype: main.raesource => [88]

属性对齐的结构体内存总共占用 structtype:d main.orderresource => [72]

改变 te3 将同时改变 te,te3 指向了 te的地址

case_test.go:186: 复制了对齐结构体，并重新赋值，用于查看字段长度。

case_test.go:188: (*te).cloud: aws-singapore *te.cloud aws-singapore te size: 16 te alignof: 8 te value len: 13 reflect align len and field align len: 8 8
case_test.go:190: (*te2).cloud: ali2 *te2.cloud aws-singapore te2 size: 16 te2 alignof: 8 te2 value len: 4 reflect align len and field align len: 8 8
case_test.go:196: (*te3).cloud: hwcloud2-asia-southeast-from-big-plant-place-air-local-video-service-picture-merge-from-other-all-company *te3.cloud hwcloud2-asia-southeast-from-big-plant-place-air-local-video-service-picture-merge-from-other-all-company te3
size: 16 te3 alignof: 8 te3 value len: 105 reflect align len and field align len: 8 8

case_test.go: 结构体1字段 cloud:hwcloud2-asia-southeast-from-big-plant-place-air-local-video-service-picture-merge-from-other-all-company te2:0xc0000621e0
case_test.go:198: 结构体2字段 cloud:ali2 te2:0xc000062280
case_test.go:199: 结构体3字段 cloud:hwcloud2-asia-southeast-from-big-plant-place-air-local-video-service-picture-merge-from-other-all-company te3:0xc0000621e0