很多现代的编程语言中都有 defer 关键字，Go 语言的 defer 会在当前函数或者方法返回之前执行传入的函数。它会经常被用于关闭文件描述符、关闭数据库连接以及解锁资源。在这一节中我们就会深入 Go 语言的源代码介绍 defer 关键字的实现原理，相信读者读完这一节会对 defer 的数据结构、实现以及调用过程有着更清晰的理解。

作为一个编程语言中的关键字，defer 的实现一定是由编译器和运行时共同完成的，不过在深入源码分析它的实现之前我们还是需要了解 defer 关键字的常见使用场景以及使用时的注意事项。

使用 defer 的最常见场景就是在函数调用结束后完成一些收尾工作，例如在 defer 中回滚数据库的事务：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func createPost(db *gorm.DB) error {
    tx := db.Begin()
    defer tx.Rollback()
    
    if err := tx.Create(&Post{Author: "Draveness"}).Error; err != nil {
        return err
    }
    
    return tx.Commit().Error
}

在使用数据库事务时，我们可以使用如上所示的代码在创建事务之后就立刻调用 Rollback 保证事务一定会回滚。哪怕事务真的执行成功了，那么调用 tx.Commit() 之后再执行 tx.Rollback() 也不会影响已经提交的事务。

现象

我们在 Go 语言中使用 defer 时会遇到两个比较常见的问题，这里会介绍具体的场景并分析这两个现象背后的设计原理：

  • defer 关键字的调用时机以及多次调用 defer 时执行顺序是如何确定的；
  • defer 关键字使用传值的方式传递参数时会进行预计算，导致不符合预期的结果；

作用域

向 defer 关键字传入的函数会在函数返回之前运行。假设我们在 for 循环中多次调用 defer 关键字：

1
2
3
4
5
6
7

func main() {
	for i := 0; i < 5; i++ {
		defer fmt.Println(i)
	}
}

$ go run main.go

运行上述代码会倒序执行所有向 defer 关键字中传入的表达式，最后一次 defer 调用传入了 fmt.Println(4)，所以会这段代码会优先打印 4。我们可以通过下面这个简单例子强化对 defer 执行时机的理解：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func main() {
    {
        defer fmt.Println("defer runs")
        fmt.Println("block ends")
    }
    
    fmt.Println("main ends")
}

$ go run main.go
block ends
main ends
defer runs

从上述代码的输出我们会发现，defer 传入的函数不是在退出代码块的作用域时执行的，它只会在当前函数和方法返回之前被调用。

预计算参数

Go 语言中所有的函数调用都是传值的，defer 虽然是关键字，但是也继承了这个特性。假设我们想要计算 main 函数运行的时间，可能会写出以下的代码：

1
2
3
4
5
6
7
8
9

func main() {
	startedAt := time.Now()
	defer fmt.Println(time.Since(startedAt))
	
	time.Sleep(time.Second)
}

$ go run main.go
0s

然而上述代码的运行结果并不符合我们的预期，这个现象背后的原因是什么呢？经过分析，我们会发现调用 defer 关键字会立刻对函数中引用的外部参数进行拷贝，所以 time.Since(startedAt) 的结果不是在 main 函数退出之前计算的，而是在 defer 关键字调用时计算的，最终导致上述代码输出 0s。

想要解决这个问题的方法非常简单，我们只需要向 defer 关键字传入匿名函数：

1
2
3
4
5
6
7
8
9

func main() {
	startedAt := time.Now()
	defer func() { fmt.Println(time.Since(startedAt)) }()
	
	time.Sleep(time.Second)
}

$ go run main.go
1s

虽然调用 defer 关键字时也使用值传递，但是因为拷贝的是函数指针，所以 time.Since(startedAt) 会在 main 函数返回前被调用并打印出符合预期的结果。

数据结构

在介绍 defer 函数的执行过程与实现原理之前，我们首先来了解一下 defer 关键字在 Go 语言源代码中对应的数据结构：

1
2
3
4
5
6
7
8
9

type _defer struct {
	siz     int32
	started bool
	sp      uintptr
	pc      uintptr
	fn      *funcval
	_panic  *_panic
	link    *_defer
}

runtime._defer 结构体是延迟调用链表上的一个元素，所有的结构体都会通过 link 字段串联成链表。

延迟调用链表
延迟调用链表

我们简单介绍一下 runtime._defer 结构体中的几个字段：

  • siz 是参数和结果的内存大小；
  • sp 和 pc 分别代表栈指针和调用方的程序计数器；
  • fn 是 defer 关键字中传入的函数；
  • _panic 是触发延迟调用的结构体，可能为空；

除了上述的这些字段之外，runtime._defer 中还包含一些垃圾回收机制使用的字段，这里为了减少理解的成本就都省去了。

编译过程

中间代码生成阶段执行的被 cmd/compile/internal/gc.state.stmt 函数会处理 defer 关键字。从下面截取的这段代码中，我们会发现编译器调用了 cmd/compile/internal/gc.state.call 函数，这表示 defer 在编译器看来也是函数调用：

1
2
3
4
5
6

func (s *state) stmt(n *Node) {
	switch n.Op {
	case ODEFER:
		s.call(n.Left, callDefer)
	}
}

cmd/compile/internal/gc.state.call 函数会负责了为所有函数和方法调用生成中间代码，它的工作包括以下内容：

  1. 获取需要执行的函数名、闭包指针、代码指针和函数调用的接收方；
  2. 获取栈地址并将函数或者方法的参数写入栈中；
  3. 使用 cmd/compile/internal/gc.state.newValue1A 以及相关函数生成函数调用的中间代码；
  4. 如果当前调用的函数是 defer，那么就会单独生成相关的结束代码块；
  5. 获取函数的返回值地址并结束当前调用；
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func (s *state) call(n *Node, k callKind) *ssa.Value {
	...
	var call *ssa.Value
	switch {
	case k == callDefer:
		call = s.newValue1A(ssa.OpStaticCall, types.TypeMem, deferproc, s.mem())
	...
	}
	call.AuxInt = stksize
	s.vars[&memVar] = call
	...
}

从上述代码中我们能看到，defer 关键字在运行期间会调用 runtime.deferproc 函数，这个函数接收了参数的大小和闭包所在的地址两个参数。

编译器不仅将 defer 关键字都转换成 runtime.deferproc 函数，它还会通过以下三个步骤为所有调用 defer 的函数末尾插入 runtime.deferreturn 的函数调用：

  1. cmd/compile/internal/gc.walkstmt 在遇到 ODEFER 节点时会执行 Curfn.Func.SetHasDefer(true) 设置当前函数的 hasdefer；
  2. cmd/compile/internal/gc.buildssa 会执行 s.hasdefer = fn.Func.HasDefer() 更新 state 的 hasdefer；
  3. cmd/compile/internal/gc.state.exit 会根据 state 的 hasdefer 在函数返回之前插入 runtime.deferreturn 的函数调用；
1
2
3
4
5
6

func (s *state) exit() *ssa.Block {
	if s.hasdefer {
		s.rtcall(Deferreturn, true, nil)
	}
	...
}

Go 语言的编译器不仅将 defer 转换成了 runtime.deferproc 的函数调用，还在所有调用 defer 的函数结尾插入了 runtime.deferreturn，接下来我们就需要了解这两个运行时方法的实现原理了。

运行过程

defer 关键字的运行时实现分成两个部分：

这两个函数是 defer 关键字运行时机制的入口，我们从它们开始分别介绍这两个函数的执行过程。

创建延迟调用

runtime.deferproc 会为 defer 创建一个新的 runtime._defer 结构体、设置它的函数指针 fn、程序计数器 pc 和栈指针 sp 并将相关的参数拷贝到相邻的内存空间中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

func deferproc(siz int32, fn *funcval) {
	sp := getcallersp()
	argp := uintptr(unsafe.Pointer(&fn)) + unsafe.Sizeof(fn)
	callerpc := getcallerpc()

	d := newdefer(siz)
	if d._panic != nil {
		throw("deferproc: d.panic != nil after newdefer")
	}
	d.fn = fn
	d.pc = callerpc
	d.sp = sp
	switch siz {
	case 0:
	case sys.PtrSize:
		*(*uintptr)(deferArgs(d)) = *(*uintptr)(unsafe.Pointer(argp))
	default:
		memmove(deferArgs(d), unsafe.Pointer(argp), uintptr(siz))
	}

	return0()
}

最后调用的 runtime.return0 函数的作用是避免无限递归调用 runtime.deferreturn，它是唯一一个不会触发由延迟调用的函数了。

runtime.deferproc 中 runtime.newdefer 的作用就是想尽办法获得一个 runtime._defer 结构体，办法总共有三个：

  1. 从调度器的延迟调用缓存池 sched.deferpool 中取出结构体并将该结构体追加到当前 Goroutine 的缓存池中；
  2. 从 Goroutine 的延迟调用缓存池 pp.deferpool 中取出结构体；
  3. 通过 runtime.mallocgc 创建一个新的结构体；
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

func newdefer(siz int32) *_defer {
	var d *_defer
	sc := deferclass(uintptr(siz))
	gp := getg()
	if sc < uintptr(len(p{}.deferpool)) {
		pp := gp.m.p.ptr()
		if len(pp.deferpool[sc]) == 0 && sched.deferpool[sc] != nil {
			for len(pp.deferpool[sc]) < cap(pp.deferpool[sc])/2 && sched.deferpool[sc] != nil {
				d := sched.deferpool[sc]
				sched.deferpool[sc] = d.link
				pp.deferpool[sc] = append(pp.deferpool[sc], d)
			}
		}
		if n := len(pp.deferpool[sc]); n > 0 {
			d = pp.deferpool[sc][n-1]
			pp.deferpool[sc][n-1] = nil
			pp.deferpool[sc] = pp.deferpool[sc][:n-1]
		}
	}
	if d == nil {
		total := roundupsize(totaldefersize(uintptr(siz)))
		d = (*_defer)(mallocgc(total, deferType, true))
	}
	d.siz = siz
	d.link = gp._defer
	gp._defer = d
	return d
}

无论使用哪种方式获取 runtime._defer，它都会被追加到所在的 Goroutine _defer 链表的最前面。

追加新的延迟调用
追加新的延迟调用

defer 关键字插入时是从后向前的，而 defer 关键字执行是从前向后的，而这就是后调用的 defer 会优先执行的原因。

执行延迟调用

runtime.deferreturn 会从 Goroutine 的 _defer 链表中取出最前面的 runtime._defer 结构体并调用 runtime.jmpdefer 函数传入需要执行的函数和参数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

func deferreturn(arg0 uintptr) {
	gp := getg()
	d := gp._defer
	if d == nil {
		return
	}
	sp := getcallersp()

	switch d.siz {
	case 0:
	case sys.PtrSize:
		*(*uintptr)(unsafe.Pointer(&arg0)) = *(*uintptr)(deferArgs(d))
	default:
		memmove(unsafe.Pointer(&arg0), deferArgs(d), uintptr(d.siz))
	}
	fn := d.fn
	gp._defer = d.link
	freedefer(d)
	jmpdefer(fn, uintptr(unsafe.Pointer(&arg0)))
}

runtime.jmpdefer 是一个用汇编语言实现的运行时函数，它的工作就是跳转 defer 所在的代码段并在执行结束之后跳转回 runtime.deferreturn。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

TEXT runtime·jmpdefer(SB), NOSPLIT, $0-8
	MOVL	fv+0(FP), DX	// fn
	MOVL	argp+4(FP), BX	// caller sp
	LEAL	-4(BX), SP	// caller sp after CALL
#ifdef GOBUILDMODE_shared
	SUBL	$16, (SP)	// return to CALL again
#else
	SUBL	$5, (SP)	// return to CALL again
#endif
	MOVL	0(DX), BX
	JMP	BX	// but first run the deferred function

runtime.deferreturn 函数会多次判断当前 Goroutine 的 _defer 链表中是否有未执行的剩余结构，在所有的延迟函数调用都执行完成之后，该函数才会返回。

小结

defer 关键字的实现主要依靠编译器和运行时的协作，我们总结一下本节提到的内容：

我们在本节前面提到的两个现象在这里也可以解释清楚了：

  • 后调用的 defer 函数会先执行：

    • 后调用的 defer 函数会被追加到 Goroutine _defer 链表的最前面；

  • 运行 runtime._defer 时是从前到后依次执行；

  • 函数的参数会被预先计算；

    • 调用 runtime.deferproc 函数创建新的延迟调用时就会立刻拷贝函数的参数，函数的参数不会等到真正执行时计算；

延伸阅读