- 后端早读课翻译计划 第三篇-

- 翻译自： a-journey-with-go

欢迎关注微信公众号： 后端早读课

本文列举在 Golang 中 unsafe 的一般用法，以及提供给开发者的一些建议。

640.png

ℹ️ 本文基于 Go 1.12 版本。

这个 Package 的名字其实已经告诉了我们，我们不应该用它。为了弄清楚为什么用它会导致不安全，我们先看下文档里说的：

Package unsafe 包含一些可以绕过类型安全的操作。

导入 unsafe 的包可能是不可移植( non-portable) 的，而且不受 Go 1 兼容性准则的保护

因此，这个命名作为 Go 中类型安全的对立面。让我们深入探究文档中提到的这两点。

Type safety

在 Go 中，每个变量都有类型，并且在赋值给其他变量之前，可以被转换成对应的类型。在这个转换过程中， Go 为了适应新的类型，会对数据进行转换。比如：

var i int8 = -1 // -1 binary representation: 11111111
var j = int16(i) // -1 binary representation: 11111111 11111111
println(i, j) // -1 -1

unsafe 包会允许我们可以直接访问存储这个变量原始二进制信息的地址。在我们想绕过类型限制的时候可以使用它：

var k uint8 = *(*uint8)(unsafe.Pointer(&i))
println(k) // 255 is the uint8 value for the binary 11111111

原始值现在被解释为 uint8，而不是用原来声明的类型的值（也可以通过强制类型转换把 int8 转为 uint8 ——译者注）。如果你对这个话题想做更深入的了解，我推荐你阅读另外一篇文章 Cast and Conversion with Go

Go 1 compatibility guidelines

Go 1 的手册清楚地说明，如果他们改变了实现方式，使用 unsafe 包可能会破坏你的代码。

引入了 unsafe 的包可能依赖于 Go 实现的内部属性。我们保留修改实现方法的权利，这也许会破坏此类程序

我们需要记住的是，在 Go 1 中，内部实现可能会发生变化，并且我们也许会遇到类似 issues this ticket in Github 中所见的问题，两个 Go 版本之间的行为有略微的改变。不过， Go 的一些标准库中也在许多地方使用了 unsafe 包。

Usage in Go with the reflection package

Reflection 包是使用 unsafe 最多的包之一。Reflection 基于空接口包含的内部数据。为了读取数据， Go 只是将我们的变量转变为空接口，并通过映射一个与空接口的内部表示形式匹配的结构和指针地址处的内存来读取它们。

func ValueOf(i interface{}) Value {
   [...]
   return unpackEface(i)
}
// unpackEface converts the empty interface i to a Value.
func unpackEface(i interface{}) Value {
   e := (*emptyInterface)(unsafe.Pointer(&i))
   [...]
}

变量 e 现在包含了关于该值的所有信息，比如类型或值是否被导出。反射也会用 unsafe 包来通过直接在内存中更新值来修改发射变量的值，就像我们之前已经看到的。

Usage in Go with the sync package

在 sync 包中，unsafe 有另一个有趣的用法。如果你不熟悉 sync 包，我推荐阅读 design of sync.Pool

共享池（Pooles) 通过一块内存片段被所有 goroutines/processors 共享，所有的 goroutines 都可以通过 unsafe 包访问它。

func indexLocal(l unsafe.Pointer, i int) *poolLocal {
   lp := unsafe.Pointer(uintptr(l) + uintptr(i)*unsafe.Sizeof(poolLocal{}))
   return (*poolLocal)(lp)
}

变量 l 就是那块内存片段， i 是 processor 编号。方法 indexLocal 只是读取这个内存片段——包括了 X ( processor 的编号）poolLocal 结构体——通过 index 的偏移量去读取。存储一个指针指向整个内存片段是实现共享池的一种非常轻量的方式。

Usage in Go with the runtime package

Go 也在 runtime 里面使用了很多次 unsafe 包，因为它需要处理内存操作，比如堆栈的分配或者释放堆栈内存。堆栈的结构中由两个边界来表示：

type stack struct {
   lo uintptr
   hi uintptr
}

然后， unsafe 包将会有助于进行以下操作：

func stackfree(stk stack) {
   [...]
   v := unsafe.Pointer(stk.lo)
   n := stk.hi - stk.lo
   // then memory freeing based on the pointer to the stack
   [...]
}

如果你想更深入的了解堆栈，可以阅读这篇文章 stack size and its management.

同时，我们可以在某些时候在我们的应用里使用这个包，比如两个 struct 之间的转换。

Usage as a developer

unsafe 包的一个优雅的用法就是用来转换两个基础数据一样的 struct，他们本来是不能被转换器转换的：

type A struct {
   A int8
   B string
   C float32

}

type B struct {
   D int8
   E string
   F float32

}

func main() {
   a := A{A: 1, B: `foo`, C: 1.23}
   //b := B(a) cannot convert a (type A) to type B
   b := *(*B)(unsafe.Pointer(&a))

   println(b.D, b.E, b.F) // 1 foo 1.23
}

source: https://play.golang.org/p/sjeO9v0T_Fs

另外一个优雅的使用方式是在 http://golang-sizeof.tips ，它可以帮助你理解 struct 填充的大小。

总结

总结来说，unsafe 包是一个比较有趣而且强大的工具，应谨慎使用。另外，如果你想对该包的未来版本进行更新，可以在这里找到建议 the proposals in Github for Go 2.

阅读原文

欢迎关注微信公众号： 后端早读课