结合源码理解interface{}

首先要明确go中的interface分为两种，无方法声明和有方法声明的的，对应源码中的定义如下:

//有方法声明
type iface struct {
    tab  *itab
    data unsafe.Pointer
}
//无方法声明
type eface struct {
    _type *_type
    data  unsafe.Pointer
}

其中data指向实际的值信息，_type是对定义内部类型信息的数据结构，itab里定义了接口相关信息，包括接口类型、实际类型、实现的方法集等：

type itab struct {
    inter  *interfacetype
    _type  *_type
    link   *itab
    hash   uint32 // copy of _type.hash. Used for type switches.
    bad    bool   // type does not implement interface
    inhash bool   // has this itab been added to hash?
    unused [2]byte
    fun    [1]uintptr // variable sized
}

interfacetype是关于一个接口本身的信息，包括这个接口的类型、包含的方法集以及包名等。
iface则对应的是把一个struct转为interface后的信息。
fun中存放了interfacetype需要的方法集的具体实现，因为方法内存中是顺序存放的，所以fun中只需要存储第一个方法地址的指针。

hashSize = 1009
hash      [hashSize]*itab

可能是为了性能考虑，所有的itab实际是存放在一个全局hash表中，当把一种interface类型转为另一种interface类型时，调用的源码是：

func convI2I(inter *interfacetype, i iface) (r iface) {
    tab := i.tab
    if tab == nil {
        return
    }
    if tab.inter == inter {
        r.tab = tab
        r.data = i.data
        return
    }
    r.tab = getitab(inter, tab._type, false)
    r.data = i.data
    return
}

可以看到当i中tab的inter和要转的inter相同时，直接就可以转换，否则要调用getitab获取待转r的itab。

func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
...
    h := itabhash(inter, typ)
    var m *itab
    var locked int
    for locked = 0; locked < 2; locked++ {
        if locked != 0 {
            lock(&ifaceLock)
        }
        for m = (*itab)(atomic.Loadp(unsafe.Pointer(&hash[h]))); m != nil; m = m.link {
          if m.inter == inter && m._type == typ {
...
            return m
          }
        }
    m = (*itab)(persistentalloc(unsafe.Sizeof(itab{})+uintptr(len(inter.mhdr)-1)*sys.PtrSize, 0, &memstats.other_sys))
    m.inter = inter
    m._type = typ
    additab(m, true, canfail)
    unlock(&ifaceLock)
    if m.bad {
        return nil
    }
    return m

上面的代码，首先是用inter和typ计算一个hash值，然后看全局itab的hash表中是否含有这个hash值的itab，如果有并且这个itab的inter和typ符合条件，则证明之前已经有过类似转换，符合类型转换条件。如果没有，再试图调用additab：

func additab(m *itab, locked, canfail bool) {
    inter := m.inter
    typ := m._type
    ...
    h := itabhash(inter, typ)
    m.link = hash[h]
    m.inhash = true
    atomicstorep(unsafe.Pointer(&hash[h]), unsafe.Pointer(m))
}

省略号的部分是判断m的typ是否实现了inter方法集的逻辑，如果没有全部实现，证明类型转换不合法m.bad会被置为true。如果转换合法，最后会把m存入全局itab hash表中。

参考文章：

• http://legendtkl.com/2017/07/01/golang-interface-implement/
• https://www.tapirgames.com/blog/golang-interface-implementation