Go语言中的init函数的执行时机_同一个包内init函数执行顺序-优快云博客

init函数的执行时机

这个涉及到
- init 函数的作用和执行顺序
- 相同个文件和不同文件中以及在不同的包中init的执行顺序
- go文件初始化的顺序

一、init 函数的作用和执行顺序

作用

init 函数是用于程序执行前做包的初始化的函数，比如初始化包里面的一些变量等等
通常在项目工程中，用来做 Http Server的初始化，DB的初始化, redis 初始化等等中间件的初始化

执行顺序

在同一个 Go 文件可以重复定义多个 init 方法, 它的执行顺序是按照代码编写的顺序依次执行
在同一个 package 里面，不同文件中的 init 方法的执行是按照文件名的顺序先后执行各个文件当中的init方法的
对于不同的package
- 如果不相互依赖的话，就会按照main包里面 import 的顺序，调用各个包中的init函数
- 存在依赖，调用顺序就变成最后被依赖的会最先被初始化
  - 比如我们的导入顺序是在main函数中依赖a模块
  - a模块又依赖b模块，b模块又依赖c模块
  - 初始化的顺序就会先初始化c这个包再初始化b这个包再初始化a这个包
  - 最后执行main方法

测试同一个 Go 文件可以重复定义多个 init 方法

main.go

package main

import (
	. "fmt"
)

// 同一个go文件中的多个init方法，按照定义的顺序执行
func init() {
	Println(1)
}

func init() {
	Println(2)
}

func main() {}

运行 $ go run main.go
输出
```
1
2
```
可见，按照定义顺序保持一致

二、相同个文件和不同文件中以及在不同的包中init的执行顺序

2.1 测试同一个包中，不同的文件中的init执行顺序

init-demo/
- go.mod
- main.go
- pkg/
  - a.go
  - b.go
  - pkg.go

pkg/a.go

package pkg
import . "fmt"

func init() {
	Println("pkg-a")
}

pkg/b.go

package pkg
import . "fmt"

func init() {
	Println("pkg-b")
}

pkg/pkg.go

package pkg
import . "fmt"

var Pkg = "pkg"

func init() {
	Println("pkg-pkg")
}

main.go

package main

import (
	. "fmt"
	"init-demo/pkg"
)

// 同一个go文件中的多个init方法，按照定义的顺序执行
func init() {
	Println(1)
}

func init() {
	Println(2)
}

func main() {
	println(pkg.Pkg)
}

执行 $ go run main.go
输出
```
pkg-a
pkg-b
pkg-pkg
1
2
pkg
```
main包依赖pkg包，先按照pkg中包名的 ascII 码的顺序依次执行init, 再执行 main包中的任务
我们知道，先执行 pkg/a.go 中的init, 再执行 pkg/b.go中的init, 再执行 pkg/pkg.go 中的init，最终执行main方法中的任务

测试导入不同的包有和没有依赖其他包的情况

init-demo/
- go.mod
- main.go
- pkg1/
  - pkg1.go
- pkg2/
  - pkg2.go

pkg1/pkg.go

package pkg1
import "fmt"

var Pkg1 = "pkg1"

func init() {
	fmt.Println("pkg1-pkg1")
}

pkg2/pkg.go

package pkg2
import "fmt"
import "init-demo/pkg3"

var Pkg2 = "pkg2"

func init() {
	fmt.Println("pkg2-pkg2")
}

pkg3/pkg.go

package pkg3
import (
	"fmt"
)

func init() {
	fmt.Println("pkg3-pkg3")
}

main.go

package main

import (
	. "fmt"
	"init-demo/pkg1"
	"init-demo/pkg2"
)

// 同一个go文件中的多个init方法，按照定义的顺序执行
func init() {
	Println(1)
}

func init() {
	Println(2)
}

func main() {
	println(pkg1.Pkg1)
	println(pkg2.Pkg2)
}

执行 $ go run main.go

输出

pkg1-pkg1
pkg3-pkg3
pkg2-pkg2
1
2
pkg1
pkg2

先执行pkg1的init，因为在main中被最先引入，优先按照import的顺序执行，接着是pkg3的init, 接着是pkg2的init
因为 pkg3被pkg2引用，这样pkg3的init优先于pkg2的init执行
最后是main包中的init和main函数的方法

三、go文件初始化的顺序

会先初始化引入的包
再初始化当前包中的常量变量
接着初始化当前包中的init函数
最后执行main函数
注意
- 一个包被引用多次，这个包的init函数只会执行一次 (按照之前的规则的执行顺序下的第一次)
- 所有的 init 函数都会在同一个 goroutine 内执行
- 注意包的循环导入问题，会出现异常: import cycle not allowed
这里不再举例