GO interface

最新推荐文章于 2024-07-13 19:43:07 发布
最新推荐文章于 2024-07-13 19:43:07 发布
阅读量403 收藏
点赞数
文章标签： go re
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/airuozhaoyang/article/details/100145262
版权

GO 语言 接口

interface

// 16 bytes on 64bit arch
type iface struct {
	tab  *itab
	data unsafe.Pointer
}
// https://github.com/golang/go/blob/bf86aec25972f3a100c3aa58a6abcbcc35bdea49/src/runtime/runtime2.go#L143-L146

tab 是 itab 对象的地址， 用来描述interface的类型和它指向的数据类型的数据结构。
data 指向interface持有的具体的数据。

每次创建接口，都会发生堆上的内存分配。

itab 结构：

// layout of Itab known to compilers
// allocated in non-garbage-collected memory
// Needs to be in sync with
// ../cmd/compile/internal/gc/reflect.go:/^func.dumptypestructs.
type itab struct {
	inter *interfacetype
	_type *_type
	hash  uint32 // copy of _type.hash. Used for type switches.
	_     [4]byte
	fun   [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
}
// https://github.com/golang/go/blob/bf86aec25972f3a100c3aa58a6abcbcc35bdea49/src/runtime/runtime2.go#L648-L658

itab 内嵌了 _type, _type 这个类型是runtime对任意GO语言类型的内部表示。
_type 类型 描述了一个“类型”的每一方面： 名字，特性，行为 等。
在这个例子中，_type字段描述了interface所持有的值的类型，也就是data指针所指向的值的类型。

_type 结构

// Needs to be in sync with ../cmd/link/internal/ld/decodesym.go:/^func.commonsize,
// ../cmd/compile/internal/gc/reflect.go:/^func.dcommontype and
// ../reflect/type.go:/^type.rtype.
type _type struct {
	size       uintptr
	ptrdata    uintptr // size of memory prefix holding all pointers
	hash       uint32
	tflag      tflag
	align      uint8
	fieldalign uint8
	kind       uint8
	alg        *typeAlg
	// gcdata stores the GC type data for the garbage collector.
	// If the KindGCProg bit is set in kind, gcdata is a GC program.
	// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
	gcdata    *byte
	str       nameOff
	ptrToThis typeOff
}
// https://github.com/golang/go/blob/bf86aec25972f3a100c3aa58a6abcbcc35bdea49/src/runtime/type.go#L25-L43

nameOff 和 typeOff 类型是int32, 这两个值是链接器负责嵌入的，相对于可执行文件的元信息的偏移量。元信息会在运行期加载到runtime.moduledata结构体中。
https://github.com/golang/go/blob/bf86aec25972f3a100c3aa58a6abcbcc35bdea49/src/runtime/symtab.go#L352-L393
runtime提供了一些helper函数，这些函数能够帮助找到moduledata的偏移量，比如

func resolveNameOff(ptrInModule unsafe.Pointer, off nameOff) name {}
func resolveTypeOff(ptrInModule unsafe.Pointer, off typeOff) *_type {}

假设t是_type的话，只要调用 resolveTypeOff(t, t.ptrToThis) 就可以返回t的一份拷贝了。

interfacetype 结构体

// 80 bytes on a 64bit arch
type interfacetype struct {
	typ     _type
	pkgpath name
	mhdr    []imethod
}

type imethod struct {
    name nameOff
    ityp typeOff
}

interfacetype 是 对于 _type的一种包装，在其顶部空间还包装了额外的interface相关的元信息。
展开iface结构

type iface struct {
	tab  *struct { // `itab`
		inter *struct {
				typ     struct {
							size       uintptr
							ptrdata    uintptr
							hash       uint32
							tflag      tflag
							align      uint8
							fieldalign uint8
							kind       uint8
							alg        *typeAlg
							gcdata    *byte
							str       nameOff
							ptrToThis typeOff
						}		
				pkgpath name
				mhdr    []imethod
			}
		
		_type *struct {
			size       uintptr
			ptrdata    uintptr // size of memory prefix holding all pointers
			hash       uint32
			tflag      tflag
			align      uint8
			fieldalign uint8
			kind       uint8
			alg        *typeAlg
			gcdata    *byte
			str       nameOff
			ptrToThis typeOff
		}

		hash  uint32
		_     [4]byte
		fun   [1]uintptr
	}

	data unsafe.Pointer
}

创建接口：
iface.go

type Mather interface {
	Add(a, b int32) int32
	Sub(a, b int64) int64
}

type Adder struct { id int32 }

//go:noinline
func (adder Adder) Add(a, b int32) int32 { return a + b }

//go:noinline
func (adder Adder) Sub(a, b int64) int64 { return a - b }

func main() {
	m := Mather(Adder{id: 6754})
	
	m.Add(10, 32)
}

剩余部分将演示一个持有T类型内容I类型的interface，即<I, T>.
比如Mather(Adder{id: 6754})就实例化了一个 iface<Mather, Adder>

;; part 1: allocate the receiver
0x001d MOVL	$6754, ""..autotmp_1+36(SP)
;; part 2: set up the itab
0x0025 LEAQ	go.itab."".Adder,"".Mather(SB), AX
0x002c MOVQ	AX, (SP)
;; part 3: set up the data
0x0030 LEAQ	""..autotmp_1+36(SP), AX
0x0035 MOVQ	AX, 8(SP)
0x003a CALL	runtime.convT2I32(SB)
0x003f MOVQ	16(SP), AX
0x0044 MOVQ	24(SP), CX

Part1:

MOVL		$6754, ""..autotmp_1+36(SP)

实例化Adder空间，Adder即Receiver.

Part2:

LEAQ 		go.itab."".Adder,"".Mather(SB), AX
MOVQ		AX, (SP)

看起来编译器已经创建了必要的itab来表示我们的iface<Mather, Adder> interface, 并以go.itab."".Adder,"".Mather(SB)供我们使用。

我们可以用伪代码来代替上面几行代码

tab := getSymAddr(`go.itab.main.Adder,main.Mather`).(*itab)

深入研究一下 go.itab."".Adder,"".Mather符号。
编译器-S 查看汇编

$ GOOS=linux GOARCH=amd64 go tool compile -S iface.go | grep -A 7 '^go.itab."".Adder,"".Mather'
go.itab."".Adder,"".Mather SRODATA dupok size=40
    0x0000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
    0x0010 8a 3d 5f 61 00 00 00 00 00 00 00 00 00 00 00 00  .=_a............
    0x0020 00 00 00 00 00 00 00 00                          ........
    rel 0+8 t=1 type."".Mather+0
    rel 8+8 t=1 type."".Adder+0
    rel 24+8 t=1 "".(*Adder).Add+0
    rel 32+8 t=1 "".(*Adder).Sub+0

第一句声明了符号和属性
go.itab."".Adder,"".Mather SRODATA dupok size=40
由于我们看的是编译器生成的间接目标文件，符号名还没有把package名字填充上。除此之外，我们的得到的是一个40字节的全局对象符号，该符号被存到二进制文件的.rodata段中。

40个字节的数据为

    0x0000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
    0x0010 8a 3d 5f 61 00 00 00 00 00 00 00 00 00 00 00 00  .=_a............
    0x0020 00 00 00 00 00 00 00 00                          ........

type itab struct { 				// 40 bytes on a 64bit arch
    inter *interfacetype 		// offset 0x00 ($00)
    _type *_type	 			// offset 0x08 ($08)
    hash  uint32	 			// offset 0x10 ($16)
    _     [4]byte	 				// offset 0x14 ($20)
    fun   [1]uintptr	 			// offset 0x18 ($24)
			 							// offset 0x20 ($32)
}

可以看到 8a 3d 5f 61 与 hash uint32 相对应。
也就是说 main.Adder的hash值已经在我们的目标文件中了。

同时，还列出了提供给链接器重定向的相关指令：

    rel 0+8 t=1 type."".Mather+0
    rel 8+8 t=1 type."".Adder+0
    rel 24+8 t=1 "".(*Adder).Add+0
    rel 32+8 t=1 "".(*Adder).Sub+0

rel 0+8 t=1 type."".Mather+0 告诉链接器，将内容的前8个字节填充为 全局目标符号 type."".Mather 的地址。
rel 8+8 t=1 type."".Adder+0 告诉链接器，将内容的8~16个字节填充为 全局目标符号 type."".Adder 的地址。

一旦链接器完成了它的工作，执行完了这些指令， 40 字节后的序列化的 itab 就完成了。
我们再看的这些代码类似以下伪代码

tab := getSymAddr(`go.itab.main.Adder,main.Main.Mather`).(*itab)

tab.inter = getSymAddr(`type.main.Mather`).(*interfacetype)
tab._type = getSymAddr(`type.main.Adder`).(*_type)

tab.fun[0] = getSymAddr(`main.(*Adder).Add`).(uintptr)
tab.fun[1] = getSymAddr(`main.(*Adder).Sub`).(uintptr)

目前以前得到了一个完整可用的itab, 如果能再有一些相关的数据塞进去，就能得到一个完成的Interface了。

Part3: 分配数据

0x0030 LEAQ	""..autotmp_1+36(SP), AX			// 36(SP) 存储着Adder对象
0x0035 MOVQ	AX, 8(SP)								// 8(SP)存储该对象的地址
0x003a CALL	runtime.convT2I32(SB)
0x003f MOVQ	16(SP), AX
0x0044 MOVQ	24(SP), CX

Part1 中说过， 栈顶 (SP) 保存这 go.itab."".Adder."".Mather 的地址。同时Part2 我们在 36(SP)中存储一个十进制常量 $6754, 我们用 8(SP) 来将栈顶下方的该变量load到寄存器中。
所以 runtime.convT2I32 的参数1为 go.itab."".Adder."".Mather 的地址， 参数2为 &Adder

看函数地址 convT2I32

func convT2I32(tab *itab, elem unsafe.Pointer) (i iface) {
    t := tab._type
    /* ...omitted debug stuff... */
    var x unsafe.Pointer
    if *(*uint32)(elem) == 0 {
        x = unsafe.Pointer(&zeroVal[0])
    } else {
        x = mallocgc(4, t, false)
        *(*uint32)(x) = *(*uint32)(elem)
    }
    i.tab = tab
    i.data = x
    return
}

runtime.convT2I32 这个函数做了4件事

  1. 创建了一个iface的结构体 i.
  2. 将我们刚给i.tab 赋的值赋予了itab指针。
  3. 它在堆上分配了一个i.tab._type的新对象 i.tab._type, 然后将第二个参数elem指向的参数拷贝到这个新对象上。
  4. 返回interface.

现在我们已经完成了下面的这些工作（伪代码）

tab := getSymAddr(`go.itab.main.Adder,main.Mather`).(*itab)
elem := getSymAddr(`""..autotmp_1+36(SP)`).(*int32)

i := runtime.convTI32(tab, unsafe.Pointer(elem))

assert(i.tab == tab)
assert(*(*int32)(i.data) == 6754) // same value..
assert((*int32)(i.data) != elem)  // ..but different (al)locations!

这些代码都是 m := Mather(Adder{id: 6754}) 这一行代码生成的。
最终，我们得到了完成的可以工作的interface.

参考：
https://github.com/go-internals-cn/go-internals/blob/master/chapter2_interfaces/README.md#%E8%A7%A3%E6%9E%84%E6%8E%A5%E5%8F%A3

朝向高处的旅途
关注
Go interface 转 string 自动适配类型
wgchen
03-14 175
Go interface 转 string 自动适配类型
go - interface 接口
农夫仔
07-17 1万+
Interface 1. 概述   Interface 是一组抽象方法(未具体实现的方法/仅包含方法名参数返回值的方法)的集合，有点像但又不同于其他编程语言中的 interface 。   如果实现了 interface 中的所有方法，即该类/对象就实现了该接口 2. interface 类型   格式： type interfaceName interface { //方
Go中的interface学习
a2225791的博客
04-24 308
学过Java的同学都知道在Java中接口更像是一种规范，用接口定义了一组方法，下面实现这个接口的类只管按照写好的方法名和返回值去实现就好，内部如何实现是各个方法自己的事情，接口本身不关注。 另外Java中实现接口的类必须显式的声明实现了哪个接口： impl...
Go语言基础结构 —— Interface 接口
xjx的博客
06-15 2199
接口是Go语言编程中数据类型的关键。在Go语言的实际编程中，几乎所有的数据结构都围绕接口展开，接口是Go语言中所有数据结构的核心。Go语言中的接口实际上是一组方法的集合,接口和gomock配合使用可以使得我们写出易于测试的代码.但是除了在反射等使用场景中我们很难直接感知到接口的存在(虽然大多数人使用反射的时候也没有感知到接口在其中发挥的作用),但是想要深入理解Go语言,我们必须对接口有足够的了解.接下来我们将从接口的数据结构、结构体如何转变成interface和Go语言中动态派发的实现这些方面来一起学习。
Go语言之interface详解
热门推荐
yuqiang870的博客
05-13 1万+
go语言interface详解，interface的使用场景，实现多态示例，
Go interface实现分析
weixin_34364071的博客
12-18 194
本文介绍了Go语言中接口（interface）的内部实现、nil interface和nil的区别以及使用时的一些坑。上篇文章回顾：Elasticsearch SQL用法详解前言接口（interface）代表一种“约定”或“协议”，是多个方法声明的集合。允许在非显示关联情况下，组合并调用其它类型的方法。接口无需依赖类型，带来的优点就是减少调用者可视化方法，隐藏类型内部结构和具体方法实现细节。虽然接...
Go语言interface 与 nil 的比较
09-21
在Go语言中，`interface`是一种特殊的类型，它允许存储任何类型的数据，只要该数据类型实现了接口中定义的所有方法。接口由一组方法签名定义，不包含任何具体的数据字段。Go的鸭子类型（duck typing）使得类型只需...
Go语言interface详解
01-01
Go语言里面设计最精妙的应该算interface，它让面向对象，内容组织实现非常的方便，当你看完这一章，你就会被interface的巧妙设计所折服。 什么是interface 简单的说，interface是一组method的组合，我们通过...
golang interface 与 反射
惜暮
02-01 2941
golang interface 与 反射golang interface 使用场景golang interface 数据结构golang interface 一些使用场景原理函数参数是 interface 的成本interface{}和带方法的interface的赋值过程动态类型与动态分发是如何实现的，动态分发什么时候进行，并且有什么样的调用成本如何进行类型转换如何进行断言，断言的成本有多高为什...
Go-interface
Linzhongyilisha的专栏
08-17 235
转载：https://www.cnblogs.com/zhangweizhong/p/9526331.html 1. 什么是interface接口 　　interface 是GO语言的基础特性之一。可以理解为一种类型的规范或者约定。它跟java，C# 不太一样，不需要显示说明实现了某个接口，它没有继承或子类或“implements”关键字，只是通过约定的形式，隐式的实现interface...
Go Interface
JunChow
01-09 200
接口(interface)是一种抽象的类型，是对其他类型行为的概括和抽象。从语法角度来看，接口是一组方法签名定义的集合。 Go语言中接口是一种数据类型，用于定义行为方法。接口是一组方法定义的集合，定义了对象的一组行为。换句话说，接口就是定义(规范或约束)。接口自身并不会实现所定义的方法，具体实现由类来完成，实现接口的类必须按照接口的声明来实现接口所提供的所有功能。接口的功能是将定义与实现分离以降低...
Go语言中interface
qq_30505673的博客
12-20 2272
interface是Go语言中最成功的设计之一，空的interface可以被当作“鸭子”类型使用，它使得Go这样的静态语言拥有了一定的动态性，但却又不损失静态语言在类型安全方面拥有的编译时检查的优势。 依赖于接口而不是实现，优先使用组合而不是继承，这是程序抽象的基本原则。但是长久以来以C++为代表的“面向对象”语言曲解了这些原则，让人们走入了误区。为什么要将方法和数据绑死？为什么要有多重继承这么变...
【Go入门】接口interface
QAQterrible的博客
11-19 122
简单的说，interface是一组method签名的组合，我们通过interface来定义对象的一组行为。我们前面一章最后一个例子中Student和Employee都能SayHi，虽然他们的内部实现不一样，但是那不重要，重要的是他们都能say hi让我们来继续做更多的扩展，Student和Employee实现另一个方法Sing，然后Student实现方法BorrowMoney而Employee实现SpendSalary。这样Student实现了三个方法：SayHi、Sing、BorrowMoney；
Go interface详解
阿俊的博客
03-30 911
如Go method中提及，Golang没有明确支持多态，但是通过其他手段可以实现类似C++中的多态特性，即本文中即将介绍的Go interface功能。 interface定义   interface(接口)是golang最重要的特性之一，Interface类型可以定义一组方法，但是这些不需要实现。请注意：此处限定是一组方法，既然是方法，就不能是变量；而且是一组，表明可以有多个方法。再多声明...
go interface
好记性不如写博客！
08-28 1460
go语言里，interface的地位举足轻重，可谓是go语言的灵魂。下面通过两个例子说明interface的使用。 示例一 package main import ( "fmt" "strconv" ) type sdxp struct{ index int name string } type idriver interface{ driver1()string driv...
GO语言中的接口（interface）
最新发布
lp15929801907的博客
07-13 1770
在Go语言中，接口（interface）是方法的集合，它允许我们定义一组方法但不实现它们，任何类型只要实现了这些方法，就被认为是实现了该接口。接口更重要的作用在于多态实现，它允许程序以多态的方式处理不同类型的值。接口体现了程序设计的多态和高内聚、低耦合的思想。
Go的接口(interface)介绍和使用
程序猿CKeen的专栏
03-21 2707
1. 接口(interface)的类型 在Go语言中接口(interface)是一种类型，是一种抽象的类型。 首先我们看系统interface类型 func main(){ // 定义一个空接口x var x interface{} fmt.Printf("type:%T value:%v\n", x, x) s := "hello world!" x = s fmt.Printf("type:%T value:%v\n", x, x) i := 128 x = i fm
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值