logo
简体中文

导航菜单

Go 语言从零开始

Unsafe 包

unsafe 包提供了绕过 Go 类型系统安全检查的能力，可以直接操作内存。它是一个特殊的标准库包，Go 官方明确警告：使用 unsafe 的程序可能不可移植，且不受 Go 1 兼容性承诺保护。本章将深入讲解 unsafe 的核心概念、使用场景和严重风险。

unsafe.Pointer 概念

unsafe.Pointer

unsafe.Pointer 是一种特殊的指针类型，可以指向任意类型的数据。它是 Go 类型系统中的”通用指针”，可以在任意指针类型之间转换。普通指针 *T 只能指向 T 类型，而 unsafe.Pointer 打破了这一限制。

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    x := 42
    p := &x                    // *int
    up := unsafe.Pointer(p)    // unsafe.Pointer — 丢失类型信息
    pi := (*int)(up)           // 重新转为 *int

    fmt.Println(*pi) // 42
}

*T 到 *U 的转换

unsafe.Pointer 的核心用途之一是在不同指针类型之间转换。Go 规范定义了 unsafe.Pointer 的合法转换模式：

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 场景 1：*float64 读写 int64 的底层字节
    var f float64 = 3.14
    var i int64 = *(*int64)(unsafe.Pointer(&f))
    fmt.Printf("float64 bits: %016x\n", uint64(i))
    // float64 bits: 40091eb851eb851f

    // 场景 2：[]byte 与 string 的零拷贝转换
    s := "hello, world!"
    b := unsafe.Slice(unsafe.StringData(s), len(s))
    fmt.Printf("bytes: %v\n", b) // [104 101 108 108 111 44 32 119 111 114 108 100 33]

    // 场景 3：string 与 []byte 互转（不安全但高效）
    hdr := (*reflect.StringHeader)(unsafe.Pointer(&s))
    // hdr.Data, hdr.Len 可以直接访问
}

指针转换规则

Go 规范定义了 unsafe.Pointer 的合法转换模式：

// ✅ 合法转换规则（Go 规范明确允许）

// 规则 1：任何 *T 都可以转换为 unsafe.Pointer
var i int = 42
p := unsafe.Pointer(&i)

// 规则 2：unsafe.Pointer 可以转换为任何 *U
u := (*float64)(p)

// 规则 3：unsafe.Pointer 可以转换为 uintptr（再转回）
// 但 uintptr 不能独立存储，必须同一表达式内转回
ptr := uintptr(p)

uintptr

uintptr 是一个无符号整数类型，足以存放任意指针的位模式。但它不是指针类型——GC 不会追踪 uintptr。

uintptr vs unsafe.Pointer

unsafe.Pointer 是 GC 可追踪的指针引用；uintptr 是无符号整数，GC 不可见。将 unsafe.Pointer 转为 uintptr 后，如果不立即在同一表达式内转回，就可能导致悬垂指针。

package main

import (
    "fmt"
    "unsafe"
)

type Point struct {
    X float64
    Y float64
}

func main() {
    p := &Point{X: 1.0, Y: 2.0}

    // ✅ 安全：同一表达式内 uintptr 转换
    yPtr := uintptr(unsafe.Pointer(&p.Y))
    fmt.Printf("Y offset: %d\n", yPtr)
    yVal := *(*float64)(unsafe.Pointer(yPtr))
    fmt.Printf("Y value: %.2f\n", yVal) // 2.0

    // ❌ 危险：拆成多步
    base := uintptr(unsafe.Pointer(&p))  // 如果发生 GC，base 可能失效
    // ... 其他操作可能触发 GC ...
    offset := base + 8                       // 手动计算偏移，可能已被回收
    ptrY := unsafe.Pointer(offset)          // 悬垂指针！
    fmt.Println("Y value: %.2f\n", *(*float64)(ptrY)) // 未定义行为
}

Sizeof / Alignof / Offsetof

unsafe 包提供了三个编译期常量函数，用于获取类型的内存布局信息：

package main

import (
    "fmt"
    "unsafe"
)

type Employee struct {
    ID      int32   // 4 bytes
    Salary  float64 // 8 bytes
    Active  bool     // 1 byte
    Name     string   // 16 bytes (ptr + len)
}

func main() {
    var e Employee

    fmt.Println("sizeof Employee:", unsafe.Sizeof(e))
    fmt.Println("alignof Employee:", unsafe.Alignof(e))
    fmt.Println("offsetof ID:", unsafe.Offsetof(e.ID))
    fmt.Println("offsetof Salary:", unsafe.Offsetof(e.Salary))
    fmt.Println("offsetof Active:", unsafe.Offsetof(e.Name))

    // 基本类型
    fmt.Println("sizeof int:", unsafe.Sizeof(int(0)))
    fmt.Println("sizeof int32:", unsafe.Sizeof(int32(0)))
    fmt.Println("sizeof string:", unsafe.Sizeof(string("")))
}

内存布局可视化

Employee 内存布局（64位系统）:
┌──────────┬───────┬──────────┬─────┬────────────────────┐
│ ID (int32) │ pad  │ Salary (f64) │Active│    Name (string)   │
│   4 bytes  │ 4B   │   8 bytes   │ 1B  │ 7B padding │ 16B   │
└──────────┴───────┴──────────┴─────┴─────────────────────┘
│ offset 0       │ offset 8      │  16  │     offset 24       │
└────────────────┴───────┴──────────┴─────┴─────────────────────┘
Total: 40 bytes, Alignment: 8

使用场景 — 高性能序列化

unsafe 最常见的合理使用场景是高性能数据序列化，避免内存拷贝：

package main

import (
    "fmt"
    "unsafe"
)

// 场景 1：[]byte ↔ string 零拷贝转换
func BytesToString(b []byte) string {
    if len(b) == 0 {
        return ""
    }
    return unsafe.String(unsafe.SliceData(b), len(b))
}

func StringToBytes(s string) []byte {
    if len(s) == 0 {
        return nil
    }
    return unsafe.Slice(unsafe.StringData(s), len(s))
}

// 场景 2：高效读取结构体为字节流
type Packet struct {
    Version uint16
    Length  uint16
    Payload [8]byte
}

func PacketToBytes(p *Packet) []byte {
    size := unsafe.Sizeof(*p)
    return unsafe.Slice((*byte)(unsafe.Pointer(p)), size)
}

// 零拷贝 10 万次 vs 标准库零拷贝
func ZeroCopyExample() {
    data := make([]byte, 0)
    for i := 0; i < 100000; i++ {
        data = append(data, "item-" + strconv.Itoa(i) + "\n")
    }

    // 标准库零拷贝
    start := time.Now()
    for i := 0; i < 100000; i++ {
        _ = string(data)
    }
    fmt.Printf("Standard copy: %v\n", time.Since(start))

    // 零拷贝
    start = time.Now()
    for i := 0; i < 100000; i++ {
        _ = BytesToString(data)
    }
    fmt.Printf("Zero-copy: %v\n", time.Since(start))
}
// 基准库零拷贝约 6ms
// 零拷贝约 3ms
// 性能提升约 2 倍
上一章节 反射（Reflect）
下一章节 其他高级特性

搜索