Golang中的init函数何时执行 剖析包初始化顺序规则

init函数在main函数之前执行，Go程序启动时先初始化依赖包：按深度优先处理包依赖，每个包内先初始化全局变量，再按声明顺序执行init函数，main包最后初始化，最终运行main函数。

Go语言中的

init

main

init

init

解决方案

init

对于每一个被初始化的包，流程是这样的：

1. 包级别的变量初始化：所有在函数外部声明的变量，也就是全局变量，会按照它们在代码中出现的顺序被初始化。

2. init

   登录后复制
   函数执行：在所有包级别的变量都初始化完毕后，该包内定义的所有

   init

   登录后复制
   函数会按照它们在源文件中出现的顺序依次执行。如果一个包有多个源文件，并且每个文件里都有

   init

   登录后复制
   函数，那么这些

   init

   登录后复制
   函数的执行顺序，Go语言规范并没有严格规定，但在实际操作中，它往往会按照文件名的字典序（lexicographical order）来执行，但这并不是一个你可以依赖的保证。所以，我个人建议，尽量不要让不同文件中的

   init

   登录后复制
   函数之间存在隐式依赖，这会给维护带来不少麻烦。
3. 依赖关系：如果一个包

   A

   登录后复制
   依赖于包

   B

   登录后复制
   ，那么包

   B

   登录后复制
   会先于包

   A

   登录后复制
   完成初始化（包括

   B

   登录后复制
   的所有变量初始化和

   B

   登录后复制
   的所有

   init

   登录后复制
   函数执行）。这个过程会递归地进行，直到所有被导入的包都初始化完毕。

4. main

   登录后复制
   函数：只有当所有被导入的包都初始化完成，并且主（

   main

   登录后复制
   ）包自身的变量和

   init

   登录后复制
   函数都执行完毕后，

   main

   登录后复制
   函数才会开始执行。

这个机制保证了程序运行的确定性，确保了在业务逻辑开始之前，所有必要的配置、资源注册、状态设置都能到位。

立即学习“go语言免费学习笔记（深入）”；

Go语言中init函数与main函数的执行顺序是怎样的？

这个问题，其实是Go程序启动流程的核心。简单讲，

init

main

init

main

具体的执行顺序是这样的： 假设你有一个

main.go

1. 导入包的初始化：Go会遍历所有被

   main

   登录后复制
   包直接或间接导入的包。对于每一个这样的包，它会先初始化该包内的所有全局变量，然后执行该包内的所有

   init

   登录后复制
   函数。这个过程是递归的，直到最深层的依赖包都被初始化完毕。

2. main

   登录后复制
   包的初始化：一旦所有导入的包都初始化完毕，Go就会开始初始化

   main

   登录后复制
   包。同样地，先初始化

   main

   登录后复制
   包内的所有全局变量，然后执行

   main

   登录后复制
   包内的所有

   init

   登录后复制
   函数。

3. 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函数执行")
}

运行这段代码，你会看到输出的顺序会是：

序列猴子开放平台

具有长序列、多模态、单模型、大数据等特点的超大规模语言模型

0

查看详情

1. mylib包：全局变量初始化

   登录后复制

2. mylib包：第一个init函数执行

   登录后复制

3. mylib包：第二个init函数执行

   登录后复制

4. main包：全局变量初始化

   登录后复制

5. main包：第一个init函数执行

   登录后复制

6. main包：第二个init函数执行

   登录后复制

7. main函数：程序开始执行

   登录后复制

8. globalVar: 我是一个全局变量

   登录后复制

9. mylib包：DoSomething函数执行

   登录后复制

这个例子清晰地展示了，导入包的初始化发生在主包之前，而全局变量的初始化又发生在

init

Golang包的初始化顺序遵循哪些规则？

Go语言的包初始化顺序，不是随便来的，它遵循一套非常明确的规则，这套规则确保了程序的确定性和可预测性。对我而言，理解这些规则就像是掌握了一张Go程序的“生命周期图”，对于设计复杂的系统结构非常有帮助。

核心规则可以概括为：深度优先、拓扑排序。

1. 依赖优先原则：如果一个包

   P

   登录后复制
   导入了包

   Q

   登录后复制
   ，那么Go语言运行时会保证包

   Q

   登录后复制
   在包

   P

   登录后复制
   之前被完全初始化。这意味着

   Q

   登录后复制
   的所有包级变量会被初始化，然后

   Q

   登录后复制
   的所有

   init

   登录后复制
   函数会执行，最后才会轮到

   P

   登录后复制
   。这个过程是递归的，直到所有依赖链上的包都完成初始化。你可以想象成一棵依赖树，Go会从树的叶子节点（没有外部依赖的包）开始向上初始化。

2. 单一初始化：每个包只会被初始化一次，即使它被多个其他包间接导入。Go运行时会跟踪哪些包已经被初始化，避免重复工作。这很关键，因为它意味着

   init

   登录后复制
   函数里的操作是幂等的，你不需要担心它被重复执行带来的副作用。

3. 避免循环依赖：Go语言不允许包之间存在循环导入（circular import）。如果在编译时检测到A导入B，B导入A这样的情况，编译器会直接报错。这是一种设计哲学，强制开发者将代码组织成一个清晰的、无环的依赖图，从而简化了初始化逻辑，也避免了运行时可能出现的死锁或无限循环。

4. 内部顺序：在一个包内部，初始化顺序是：

   • 变量初始化：包级别的变量会按照它们在源代码中声明的顺序进行初始化。如果一个变量的初始化依赖于另一个变量，Go会确保被依赖的变量先初始化。

   • init

     登录后复制
     函数执行：所有

     init

     登录后复制
     函数会在所有包级变量初始化完成后，按照它们在源文件中出现的顺序依次执行。这里再次强调，对于同一个包内不同文件中的

     init

     登录后复制
     函数，它们的执行顺序是未指定的（虽然实践中常按文件名字典序），因此，不要在它们之间建立隐式依赖。

举个例子，假设你的项目结构是这样的：

- myapp/
  - main.go
  - config/
    - config.go
  - db/
    - db.go
  - util/
    - util.go

以上就是Golang中的init函数何时执行 剖析包初始化顺序规则的详细内容，更多请关注php中文网其它相关文章！