Go Interface 底层原理

eface（空接口 interface{}）:
  ┌──────┬──────┐
  │ _type│ data │  → _type 指向类型元数据，data 指向实际值
  └──────┴──────┘

iface（有方法的接口）:
  ┌──────┬──────┐
  │ tab  │ data │  → tab 指向 itab（接口表：类型信息 + 方法表）
  └──────┴──────┘

itab:
  ┌─────────┬───────────┬──────────┐
  │ inter   │  _type    │  fun[0]  │  → fun 数组存方法指针
  └─────────┴───────────┴──────────┘

var p *int = nil     // p 本身是 nil 指针

var i interface{} = p
// i._type = *int （非 nil！）
// i.data = nil

fmt.Println(i == nil)  // false！
// 因为 _type 不为 nil

// ✅ 真 nil 接口
var j interface{}     // _type=nil, data=nil
fmt.Println(j == nil) // true

// 类型断言（运行时检查，可能 panic）
var i interface{} = "hello"
s := i.(string)     // ✅ 成功
n := i.(int)        // ❌ panic: interface conversion

// 安全断言（comma-ok 模式）
s, ok := i.(string)  // ok=true
n, ok := i.(int)     // ok=false, n=0

// 类型 switch
switch v := i.(type) {
case string:  fmt.Println("string:", v)
case int:     fmt.Println("int:", v)
default:      fmt.Println("unknown")
}

type Speaker interface {
    Speak()
}

type Dog struct{}

func (d Dog) Speak() {}       // 值接收者 → Dog 和 *Dog 都实现 Speaker
func (d *Dog) Bark() {}       // 指针接收者 → 只有 *Dog 实现 Barker

type Device interface {
    GetID() string
    GetStatus() (*DeviceStatus, error)
    SendCommand(cmd Command) error
}

type Pump struct { ID string; Speed int }
func (p *Pump) GetID() string { return p.ID }
func (p *Pump) GetStatus() (*DeviceStatus, error) { /* ... */ }
func (p *Pump) SendCommand(cmd Command) error { /* ... */ }

// 统一处理不同设备
func processDevice(d Device) {
    status, _ := d.GetStatus()
    // ...
}

pump := &Pump{ID: "pump-01"}
processDevice(pump)  // ✅ *Pump 实现了 Device

// runtime/iface.go
// 将具体类型 T 的值转换为 eface
func convT2E(t *_type, elem unsafe.Pointer) (e eface) {
    // 1. 如果类型不包含指针（如 int），直接在栈上操作，不逃逸到堆
    // 2. 如果类型包含指针，mallocgc 分配堆内存并复制
    if isDirectIface(t) {
        // 某些小类型（指针、整型小于等于指针大小）可以直接存到 data 字段
        // 不需要堆分配
        e._type = t
        // data 直接指向 elem（在栈上）
    } else {
        // 大类型或包含指针的类型 → 堆分配
        x := mallocgc(t.size, t, true) // GC 会扫描
        typedmemmove(t, x, elem)
        e._type = t
        e.data = x
    }
    return
}

func convT2I(tab *itab, elem unsafe.Pointer) (i iface) {
    i.tab = tab
    if isDirectIface(tab._type) {
        i.data = elem
    } else {
        x := mallocgc(tab._type.size, tab._type, true)
        typedmemmove(tab._type, x, elem)
        i.data = x
    }
    return
}

var x int = 42
var i interface{} = x  // 编译器插入 convT2E，int 属于 isDirectIface → 不堆分配

type MyStruct struct { data [1024]byte }
var ms MyStruct
var j interface{} = ms // 1KB 结构体，不满足 isDirectIface → mallocgc 堆分配

var k io.Writer = os.Stdout // *os.File 是指针 → isDirectIface → 不堆分配

// 情况 1：具体值赋给 interface → 一般逃逸
func escapeToHeap() interface{} {
    x := 42
    return x  // x 逃逸到堆（因为 interface 可能比 x 活得久）
}

// 情况 2：赋给接受 interface 参数的函数 → 逃逸
func process(v interface{}) {}
func caller() {
    x := 100
    process(x) // x 逃逸（编译器保守分析：process 可能持有引用）
}

// 情况 3：指针类型赋给 interface → 不逃逸（数据已在堆上）
func noEscape() io.Writer {
    f, _ := os.Create("tmp")
    return f  // *os.File 本身在堆上，装箱时 data 存指针，不额外分配
}

// 情况 4：小整数 → Go 1.15+ 优化，不逃逸（isDirectIface）
func smallIntNoEscape() interface{} {
    x := 100
    return x  // Go 1.15+ int ≤ 指针大小 → 不逃逸
}

go build -gcflags="-m" main.go
# ./main.go:5:2: x escapes to heap  ← 表明装箱触发逃逸

// runtime/runtime2.go
type itab struct {
    inter *interfacetype // 接口类型信息（方法签名列表）
    _type *_type         // 具体类型信息（如 *Pump 的元数据）
    hash  uint32         // _type.hash 的拷贝，用于 interface 比较时的快速路径
    _     [4]byte        // 填充对齐
    fun   [1]uintptr     // 变长数组：实际长度 = 接口方法数
                         // fun[0] 是第一个方法，fun[1] 是第二个...
}

type interfacetype struct {
    typ     _type       // 接口自身的类型信息
    pkgpath name        // 包路径
    mhdr    []imethod   // 方法列表（按方法名字典序排列）
}

type imethod struct {
    name nameOff  // 方法名偏移
    ityp typeOff  // 方法签名偏移
}

// 假设接口有 3 个方法：Read、Write、Close
// fun[0] → Read 的实现函数指针
// fun[1] → Write 的实现函数指针
// fun[2] → Close 的实现函数指针
//
// 实际分配时，itab 的大小是 sizeof(itab) + (方法数-1)*sizeof(uintptr)
// 因为 fun 声明为 [1]uintptr 但实际用了更大的数组

// runtime/iface.go
// 全局 itab 缓存表，固定大小 2^itabHashPower（通常是 2048 个槽）
const itabHashPower = 11 // 2^11 = 2048

var itabTable = &itabTableInit

type itabTableType struct {
    size    uintptr             // 当前表大小（2 的幂）
    count   uintptr             // 当前条目数
    entries [itabInitSize]*itab // 哈希槽数组
}

func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
    // 1. 计算 hash：(inter.typ.hash ^ typ.hash) & (size-1)
    //    用接口类型 hash 和具体类型 hash 做 XOR
    h := itabHashFunc(inter, typ)
    
    // 2. 遍历 hash 桶，比对 inter 和 _type
    var m *itab
    for m = itabTable.entries[h]; m != nil; m = m.link {
        if m.inter == inter && m._type == typ {
            // 命中！约 50% 概率
            return m
        }
    }
    
    // 3. 未命中：调用 itabAdd 生成新的 itab 并加入缓存
    m = itabAdd(inter, typ, canfail)
    return m
}

// 1. 具体类型断言 → 编译时确定（零开销）
var w io.Writer = os.Stdout
f := w.(*os.File)  // 编译器知道 *os.File 实现了 io.Writer
                    // 直接用编译期生成的 itab 比对，无需查表

// 2. 接口类型断言 → 查 itab 缓存（有开销）
var v interface{} = someValue
r, ok := v.(io.Reader)  // v 的具体类型未知，需要运行时查 itab

// 3. 类型 switch → 编译器可能生成跳转表
switch x := v.(type) {
case int:     // 直接比对 _type
case string:  // 直接比对 _type
case io.Writer: // 查 itab
}

switch v.(type) {
case int, int32, int64:     // 具体类型 → OCFI 优化，直接比 _type
case string:                // 具体类型 → 直接比 _type
case io.Writer:             // 接口类型 → 无法 OCFI，查 itab
}

// 陷阱 1：动态类型不可比较时，== 会 panic
var a interface{} = []int{1, 2, 3}  // slice 不可比较
var b interface{} = []int{1, 2, 3}
// fmt.Println(a == b)  // ❌ panic: comparing uncomparable type []int

// 陷阱 2：map 类型同样不可比较
var c interface{} = map[string]int{"a": 1}
var d interface{} = map[string]int{"a": 1}
// fmt.Println(c == d)  // ❌ panic: comparing uncomparable type map[string]int

// 陷阱 3：可比较类型正常工作
var e interface{} = "hello"
var f interface{} = "hello"
fmt.Println(e == f)  // ✅ true

// 陷阱 4：nil 接口和 nil 具体值的比较
var p *int = nil
var i interface{} = p
fmt.Println(i == nil)  // false！动态类型 *int 不为 nil

// runtime/alg.go
func efaceeq(a, b eface) bool {
    if a._type != b._type {
        return false
    }
    if a._type == nil {
        return true
    }
    // 调用类型特定的 equal 函数
    // 如果是 slice/map/func → equal 函数会 panic
    return a._type.equal(a.data, b.data)
}

m := map[interface{}]string{}
m["ok"] = "works"        // ✅ string 可比较
// m[[]int{1}] = "bad"  // ❌ 编译期就阻止了（常量不可比较类型作为 key）
var s interface{} = []int{1}
// m[s] = "bad"          // 编译通过，但运行时会查 equal 函数 → panic

type Big struct { data [256]byte }

// 值接收者实现接口
func (b Big) Process() {}
// 指针接收者实现接口
func (b *Big) ProcessPtr() {}

var big Big

// 场景 1：值接收者 → 装箱时复制 256 字节
var v interface{} = big  // 栈上 256B → 堆上 256B（mallocgc + memmove）

// 场景 2：指针接收者 → 装箱时只复制 8 字节（指针）
var v2 interface{} = &big // 栈上 8B 指针 → 直接存入 data

// Benchmark 数据（近似）：
// 值接收者装箱：~20ns（含堆分配）
// 指针接收者装箱：~2ns（无堆分配）

// 泛型约束
func Print[T fmt.Stringer](v T) {
    fmt.Println(v.String())
}

// 等价于（非泛型版本）
func PrintInterface(v fmt.Stringer) {
    fmt.Println(v.String())
}

// 泛型：单态化（monomorphization）+ 类型参数推断
// 编译器为每个具体类型生成独立的函数拷贝，零装箱开销
func Max[T constraints.Ordered](a, b T) T {
    if a > b { return a }
    return b
}

// 调用时：
n := Max(3, 5)        // 编译器生成 Max[int]，内联，无装箱
s := Max("a", "b")    // 编译器生成 Max[string]，内联，无装箱

// 对比 interface 版本：
func MaxInterface(a, b interface{}) interface{} {
    // 每次调用都要装箱/拆箱，类型断言，运行时类型检查
    // 性能远低于泛型版本
}

// 联合类型约束（Union constraint）
type Number interface {
    int | int64 | float64  // 只能用在这些具体类型上
}

// 近似约束（Approximation constraint）
type AnyInt interface {
    ~int | ~int64  // ~ 表示底层类型为 int/int64 的所有类型
}

type MyInt int
func Sum[T AnyInt](a, b T) T { return a + b }
Sum(MyInt(1), MyInt(2))  // ✅ ~int 包含 MyInt

type Walker interface {
    Walk(distance int)
}

type Dog struct{}

func (d Dog) Walk(distance int) {}      // 值方法
func (d *Dog) Run(speed int) {}         // 指针方法

// Dog 的方法集：{Walk(int)}
// *Dog 的方法集：{Walk(int), Run(int)}

// 编译器内部：方法集存储在 _type 的 moff 偏移处
// 查找过程类似：在方法列表中二分查找方法名

var d Dog
var w Walker = d   // ❌ 编译错误：Dog does not implement Walker (Walk method has pointer receiver)
                    // 但 Dog 有 Walk 方法啊？——等一下，这个例子不对
                    
// 正确例子：接口需要指针方法，值类型无法实现
type Runner interface {
    Run(int)
}
var r Runner = Dog{}   // ❌ Dog does not implement Runner (Run has pointer receiver)
var r2 Runner = &Dog{} // ✅ *Dog implements Runner

// 典型坑：map 中的值不可寻址
m := map[string]Dog{"a": Dog{}}
// m["a"].Run(10)  // ❌ 编译错误：cannot take address of m["a"]
// 如果 Go 允许值类型自动取地址，这里就会悄悄失败