init函数在main函数之前执行，Go程序启动时先初始化依赖包：按深度优先处理包依赖，每个包内先初始化全局变量，再按声明顺序执行init函数，main包最后初始化，最终运行main函数。
Go语言中的
init函数，说白了，它就是个“幕后英雄”，总是在
main函数执行之前，把该准备的都准备好。具体来说，当你的Go程序启动时，或者说，当一个包被引入（import）时，Go运行时会确保这个包里的所有
init函数都跑一遍。而且，每个
init函数只会执行一次，这是个非常重要的特性。
解决方案
init函数的执行时机和包的初始化顺序紧密相连。你可以这样理解：当Go程序开始运行，它首先会解析所有的包依赖。这个过程就像在构建一个复杂的家谱图。从最没有依赖的包开始，Go会一步步地进行初始化。
对于每一个被初始化的包，流程是这样的：
- 包级别的变量初始化：所有在函数外部声明的变量，也就是全局变量，会按照它们在代码中出现的顺序被初始化。
-
init
函数执行：在所有包级别的变量都初始化完毕后，该包内定义的所有init
函数会按照它们在源文件中出现的顺序依次执行。如果一个包有多个源文件，并且每个文件里都有init
函数，那么这些init
函数的执行顺序，Go语言规范并没有严格规定，但在实际操作中，它往往会按照文件名的字典序（lexicographical order）来执行，但这并不是一个你可以依赖的保证。所以，我个人建议，尽量不要让不同文件中的init
函数之间存在隐式依赖，这会给维护带来不少麻烦。 -
依赖关系：如果一个包
A
依赖于包B
，那么包B
会先于包A
完成初始化（包括B
的所有变量初始化和B
的所有init
函数执行）。这个过程会递归地进行，直到所有被导入的包都初始化完毕。 -
main
函数：只有当所有被导入的包都初始化完成，并且主（main
）包自身的变量和init
函数都执行完毕后，main
函数才会开始执行。
这个机制保证了程序运行的确定性，确保了在业务逻辑开始之前，所有必要的配置、资源注册、状态设置都能到位。
立即学习“go语言免费学习笔记（深入）”；
Go语言中init函数与main函数的执行顺序是怎样的？
这个问题，其实是Go程序启动流程的核心。简单讲，
init函数总是在
main函数之前执行，这是Go语言的铁律。我通常会把
init函数看作是程序的“前奏曲”，它负责为
main函数，也就是“正片”，做好一切铺垫。
具体的执行顺序是这样的： 假设你有一个
main.go文件，里面引用了其他包。
-
导入包的初始化：Go会遍历所有被
main
包直接或间接导入的包。对于每一个这样的包，它会先初始化该包内的所有全局变量，然后执行该包内的所有init
函数。这个过程是递归的，直到最深层的依赖包都被初始化完毕。 -
main
包的初始化：一旦所有导入的包都初始化完毕，Go就会开始初始化main
包。同样地，先初始化main
包内的所有全局变量，然后执行main
包内的所有init
函数。 -
main
函数执行：只有当上述所有步骤都完成后，main
函数才会被调用，程序的主逻辑才真正开始运行。
来看个小例子，这能帮你更好地理解：
package main
import (
"fmt"
"myproject/mylib" // 假设有这么一个库
)
var globalVar = initGlobalVar()
func initGlobalVar() string {
fmt.Println("main包：全局变量初始化")
return "我是一个全局变量"
}
func init() {
fmt.Println("main包：第一个init函数执行")
}
func init() {
fmt.Println("main包：第二个init函数执行")
}
func main() {
fmt.Println("main函数：程序开始执行")
fmt.Println("globalVar:", globalVar)
mylib.DoSomething() // 调用mylib包的函数
}假设
myproject/mylib/mylib.go内容如下：
package mylib
import "fmt"
var libVar = initLibVar()
func initLibVar() string {
fmt.Println("mylib包：全局变量初始化")
return "我是mylib的变量"
}
func init() {
fmt.Println("mylib包：第一个init函数执行")
}
func init() {
fmt.Println("mylib包：第二个init函数执行")
}
func DoSomething() {
fmt.Println("mylib包：DoSomething函数执行")
}运行这段代码，你会看到输出的顺序会是：
mylib包：全局变量初始化
mylib包：第一个init函数执行
mylib包：第二个init函数执行
main包：全局变量初始化
main包：第一个init函数执行
main包：第二个init函数执行
main函数：程序开始执行
globalVar: 我是一个全局变量
mylib包：DoSomething函数执行
这个例子清晰地展示了，导入包的初始化发生在主包之前，而全局变量的初始化又发生在
init函数之前。
Golang包的初始化顺序遵循哪些规则？
Go语言的包初始化顺序，不是随便来的，它遵循一套非常明确的规则，这套规则确保了程序的确定性和可预测性。对我而言，理解这些规则就像是掌握了一张Go程序的“生命周期图”，对于设计复杂的系统结构非常有帮助。
核心规则可以概括为：深度优先、拓扑排序。
依赖优先原则：如果一个包
P
导入了包Q
，那么Go语言运行时会保证包Q
在包P
之前被完全初始化。这意味着Q
的所有包级变量会被初始化，然后Q
的所有init
函数会执行，最后才会轮到P
。这个过程是递归的，直到所有依赖链上的包都完成初始化。你可以想象成一棵依赖树，Go会从树的叶子节点（没有外部依赖的包）开始向上初始化。单一初始化：每个包只会被初始化一次，即使它被多个其他包间接导入。Go运行时会跟踪哪些包已经被初始化，避免重复工作。这很关键，因为它意味着
init
函数里的操作是幂等的，你不需要担心它被重复执行带来的副作用。避免循环依赖：Go语言不允许包之间存在循环导入（circular import）。如果在编译时检测到A导入B，B导入A这样的情况，编译器会直接报错。这是一种设计哲学，强制开发者将代码组织成一个清晰的、无环的依赖图，从而简化了初始化逻辑，也避免了运行时可能出现的死锁或无限循环。
-
内部顺序：在一个包内部，初始化顺序是：
- 变量初始化：包级别的变量会按照它们在源代码中声明的顺序进行初始化。如果一个变量的初始化依赖于另一个变量，Go会确保被依赖的变量先初始化。
-
init
函数执行：所有init
函数会在所有包级变量初始化完成后，按照它们在源文件中出现的顺序依次执行。这里再次强调，对于同一个包内不同文件中的init
函数，它们的执行顺序是未指定的（虽然实践中常按文件名字典序），因此，不要在它们之间建立隐式依赖。
举个例子，假设你的项目结构是这样的：
- myapp/
- main.go
- config/
- config.go
- db/
- db.go
- util/
- util.go 
