go 接口学习笔记

Posted lubanseven

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了go 接口学习笔记相关的知识,希望对你有一定的参考价值。


这里是对接口在汇编层面上转换和实现的小结,详细了解可参考 Go 语言接口的原理

1. 类型转换:结构体到接口

1.1 结构体方法实现接口

package main

type Duck interface 
        Quack()


type Cat struct 
        Name string


//go:noinline
func (c Cat) Quack() 
        println(c.Name + " handsome")


func main() 
        var c Duck = CatName: "lubanseven"
        c.Quack()

将汇编实现分为三块:

  1. 结构体初始化;
  2. 结构体到接口类型转换;
  3. 调用结构体方法;

1.1.1 结构体初始化

XORPS   X0, X0						;; X0 = 0
MOVUPS  X0, ""..autotmp_1+48(SP)			;; StringHeader(SP+48).Data = 0
LEAQ    go.string."lubanseven"(SB), AX			;; AX = &"lubanseven"
MOVQ    AX, ""..autotmp_1+48(SP)			;; StringHeader(SP+48).Data = AX = &"lubanseven"
MOVQ    $10, ""..autotmp_1+56(SP)			;; StringHeader(SP+56).Len = 10

示意图如下:

1.1.2 结构体到接口类型转换

LEAQ    go.itab."".Cat,"".Duck(SB), AX		;; AX = itab = &(go.itab."".Cat,"".Duck)
MOVQ    AX, (SP)				;; SP = AX
LEAQ    ""..autotmp_1+48(SP), AX		;; AX = StringHeader(SP+48).Data
MOVQ    AX, 8(SP)				;; SP + 8 = AX
CALL    runtime.convT2I(SB)			;; runtime.convT2I(SP, SP+8)

查看 runtime.convT2I 函数的实现:

func convT2I(tab *itab, elem unsafe.Pointer) (i iface) 
	t := tab._type
	if raceenabled 
		raceReadObjectPC(t, elem, getcallerpc(), funcPC(convT2I))
	
	if msanenabled 
		msanread(elem, t.size)
	
	x := mallocgc(t.size, t, true)
	typedmemmove(t, x, elem)
	i.tab = tab
	i.data = x
	return

runtime.convT2I 函数会返回 runtime.iface 结构体,该结构体表示包含方法的接口。其中,函数内通过获取的类型分配内存空间,并将 elem 指针指向的内容拷贝到堆中。

返回的 runtime.iface 结构体将放在栈上的 SP+16 ~ SP+32 处,分别表示 iface.tab 和 iface.data。

示意图如下:

1.1.3 调用结构体方法

MOVQ    16(SP), AX
MOVQ    24(SP), CX
MOVQ    AX, "".c+32(SP)
MOVQ    CX, "".c+40(SP)
MOVQ    "".c+32(SP), AX

MOVQ    24(AX), AX					;; AX = *AX + 24 = iface.tab.fun[0] = Cat.Quack()
MOVQ    "".c+40(SP), CX					;; CX = iface.data
MOVQ    CX, (SP)					;; SP = CX
CALL    AX						;; CX.Quack()

其中,MOVQ 24(AX), AX 表示将 iface.tab 中指向方法 Quack() 的指针赋给 AX。由于 Duck 接口只有一个 Quack 方法,因此这里 24(AX) 索引到的即是第一个方法指针。

最后,CALL AX 传递 (SP) 的结构体值,实现 Quack() 方法的调用。

示意图如下:

1.2 结构体指针方法实现接口

package main

type Duck interface 
        Quack()


type Cat struct 
        Name string


//go:noinline
func (c *Cat) Quack() 
        println(c.Name + " handsome")


func main() 
        var c Duck = &CatName: "lubanseven"
        c.Quack()

同样的,将汇编实现分为三块:

  1. 结构体初始化;
  2. 结构体到接口类型转换;
  3. 调用结构体方法;

1.2.1 结构体初始化

LEAQ    type."".Cat(SB), AX				;; AX = &type."".Cat
MOVQ    AX, (SP)					;; SP = AX = &type."".Cat

CALL    runtime.newobject(SB)				;; SP + 8 = &Cat
MOVQ    8(SP), DI					;; DI = SP + 8
MOVQ    DI, ""..autotmp_2+16(SP)			;; SP + 16 = DI

MOVQ    $10, 8(DI)					;; *DI + 8 = StringHeader(DI.Name).Len = 10
LEAQ    go.string."lubanseven"(SB), AX			;; AX = &"lubanseven"
MOVQ    AX, (DI)					;; *DI = StringHeader(DI.Name).Data = AX

需要说明的是,LEAQ type."".Cat(SB), AX 将指向类型 Cat 的指针赋给 AX。runtime.newobject(SB) 创建结构体 Cat 的实例。通过 DI 寄存器对结构体变量赋值,注意字符串 string 的结构体实现是 StringHeader...。

示意图如下:

1.2.2 结构体到接口类型转换

MOVQ    ""..autotmp_2+16(SP), AX

LEAQ    go.itab.*"".Cat,"".Duck(SB), CX

MOVQ    CX, "".c+32(SP)
MOVQ    AX, "".c+40(SP)

结构体到接口类型的转换即转换为接口结构体 runtime.iface。其中,SP+32 表示 iface.tab,SP+40 表示 iface.data。SP+32 ~ SP+48 共同组成了接口结构体 runtime.iface,实现结构体 Cat 到接口类型的转换。

示意图如下:

1.2.3 调用指针接收者方法

MOVQ    "".c+32(SP), AX
MOVQ    24(AX), AX

MOVQ    "".c+40(SP), CX
MOVQ    CX, (SP)
CALL    AX

此例和 1.1.3 节类似,这里不加以描述了。

2. 类型转换:接口到结构体

除了结构体到接口的类型转换,go 也有接口到结构体类型的转换。通过类型断言可以实现,但类型断言背后做了些什么呢?

这里分空接口和非空接口两种情况查看接口到结构体类型转换。

2.1 非空接口

接口到结构体转换示例代码:

func main() 
	var c Duck = &CatName: "lubanseven"
	switch c.(type) 
	case *Cat:
		cat := c.(*Cat)
		cat.Quack()
	

从汇编代码看 Cat 结构体和接口结构体 runtime.iface 的创建过程类似,这里忽略。直接看最关键的接口类型到结构体类型的转换过程:

00079       LEAQ    go.itab.*"".Cat,"".Duck(SB), CX		;; CX = &(go.itab.*"".Cat,"".Duck)
00086       MOVQ    CX, "".c+56(SP)				;; SP + 56 = CX
00101       MOVQ    "".c+56(SP), CX				;; CX = SP + 56

00125       MOVL    16(CX), AX					;; AX = *CX + 16 = runtime.iface.itab.hash

00132       CMPL    AX, $593696792				;; if runtime.iface.itab.hash == $593696792 
00137       JEQ     141
00139       JMP     236

00176       MOVQ    "".c+64(SP), AX 				;; 		AX = &CatName: "lubanseven"
00205       MOVQ    AX, (SP)					;; 		SP = AX
00209       CALL    "".(*Cat).Quack(SB)				;; 		SP.Quack()
00214       JMP     216

00236       JMP     228						;;  else 
00228       JMP     230						;; 
00230       JMP     216						;;
00216       MOVQ    104(SP), BP					;; 		BP = SP + 104 
00221       ADDQ    $112, SP					;; 		SP = SP + 112
00225       RET							;; 

可以看到,类型转换实际上是通过比较 runtime.iface.itab.hash 和结构体 hash 判断类型是否相等,如果相等调用结构体,实现方法调用。如果不相等,则回收函数栈空间。

2.2 空接口

对于空接口类型转换,编译器省略了将结构体转换为 runtime.eface 的过程,从汇编代码上并未看到转换过程。和非空接口逻辑类似,空接口转换也需判断 hash 值,不过空接口的 hash 从 runtime.eface._type 获取。

3. 总结:

本篇学习笔记大致介绍了接口和结构体类型的互相转换过程,通过汇编代码分析转换的底层逻辑实现知其然,知其所以然。


以上是关于go 接口学习笔记的主要内容,如果未能解决你的问题,请参考以下文章

go语言学习笔记 — 进阶 — 接口(2.3):接口无法实现的例子

Go ASM 学习笔记之 ppt 版

go语言学习笔记 — 进阶 — 接口:在接口和类型之间转换

go语言学习笔记 — 进阶 — 接口:接口的嵌套组合 —— 把多个接口放到一个接口内

go语言学习笔记 — 进阶 — 接口:使用类型分支,批量判断空接口中变量的类型

go语言学习笔记 — 进阶 — 接口:空接口类型interface{} —— 能保存所有值