Go学习记录之runtime包深入解析

目录

• 前言：
• 一、runtime包内容学习
• 1、作用：
• ① Goroutine和并发控制：
• ② 垃圾回收：
• ③ 栈和堆操作：
• ④ 系统信息和调试：
• ⑤ 错误处理：
• ⑥ P操作：
• ⑦ 信号处理：
• 2、相关函数：
• ① Goroutine相关：
• ② 垃圾回收：
• ③ 栈：
• ④ 内存统计：
• ⑤ 并发控制：
• 3、几个较为重要的函数：
• ① runtime.Gosched()：让出CPU时间片，重新等待安排任务
• ② runtime.Goexit()：退出当前协程
• ③ runtime.GOMAXPROCS：
• 二、底层设计：
• 1、内存管理与垃圾回收的底层协作
• ① 内存分配策略
• ② 垃圾回收协同工作
• 2、协程调度的底层实现细节
• 3、运行时类型信息与反射支持
• 4、runtime包与开发者实践
• 总结 

前言：

先前学习到goroutine协程与channel调节并发同步时，有涉及到关于runtime包管理goroutine运行时的知识点。由于没有接触过，并且出于goroutine的重要性（runtime听着很高大上）的原因，通过多方学习并博客记录。

一、runtime包内容学习

1、作用：

其作用主要是与程序的运行时环境进行交互，提供了一系列函数和变量，用于控制、管理和监视程序的执行：

① Goroutine和并发控制：

runtime包提供了一些函数来管理goroutine，如创建php和销毁goroutine、设置最大可同时执行的CPU数目等，以及用于并发控制的函数，如让出CPU时间片、锁定和解锁goroutine到线程等。

package main

import (
    "fmt"
    "runtime"
    "time"
)

func worker() {
    defer fmt.Println("Worker exiting")
    runtime.Gosched() // 主动让出 CPU
    fmt.Println("Worker running")
}

func main() {
    go worker()
    time.Sleep(time.Second)
    fmt.Println("Number of goroutines:", runtime.NumGoroutine())
}

② 垃圾回收：

Go语言使用自动垃圾回收机制来管理内存，runtime包提供了手动触发垃圾回收、设置垃圾回收的百分比、获取内存统计信息等函数，用于对垃圾回收进行调控和监测。

func main() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("Allocated memory: %d bytes\n", m.Alloc)
    runtime.GC() // 手动触发 GC
    runtime.ReadMemStats(&m)
    fmt.Printf("After GC: %d bytes\n", m.Alloc)
}

③ 栈和堆操作：

runtime包提供了函数来获取当前goroutine的堆栈信息、完整的堆栈跟踪，以及对堆栈进行分析和剖析的相关函数。

④ 系统信息和调试：

runtime包提供了获取CPU核心数、CPU性能分析、调试信息等函数，可以用于获取关于系统的一些基本信息和进行程序的调试。

⑤ 错误处理：

runtime包提供了获取调用栈信息、根据PC地址获取函数信息等函数，用于错误处理和调试时追踪错误发生的位置。

func printStack() {
    var buf [4096]byte
    n := runtime.Stack(buf[:], false)
    fmt.Printf("Stack trace:\n%s\n", string(buf[:n]))
}

func main() {
    defer printStack()
    panic("Something went wrong!")
}

⑥ P操作：

runtime包提供了与处理器（P）的相关操作，如获取可同时执行的最大P数目、绑定goroutine到特定的P等。

⑦ 信号处理：

runtime包提供了处理C语言信号的函数，用于和外部C库进行交互时的信号处理。

通过使用runtime包提供的函数和变量，可以更控制程序的运行时行为、优化性能、处理错误和调试问题。但需要注意，对runtime包过度依赖可能会降低代码的可移植性

2、相关函数：

runtime包提供了与程序运行时环境交互的函数和变量，包含了与上述作用相关的函数：

① Goroutine相关：

goexit()：终止当前goroutine的执行。

GOMAXPROCS(n int)：设置可同时执行的最大CPU数。

NumGoroutine()：返回当前存在的goroutine数目。

② 垃圾回收：

GC(): 手动触发垃圾回收。

SetFinalizer(obj interface{}, finalizerpython interface{})：为对象设置一个垃圾回收的终结器（finalizer），当对象被垃圾回收时，终结器会被调用。

③ 栈：

Stack(buf []byte, all bool): 返回当前goroutine的堆栈信息。

StackTrace(p *Profiling):：返回当前程序的完整堆栈跟踪。

④ 内存统计：

ReadMemStats(m *MemStats): 获取当前程序的内存使用统计信息。

⑤ 并发控制：

LockOSThread(): 锁定当前goroutine到当前线程上。

UnlockOSThread(): 解除当前goroutine对当前线程的锁定。

（等）

同样的，由于其对底层进行交互，过多使用相关函数也会降低可移植性，开发过程中需要注意。

3、几个较为重要的函数：

① runtime.Gosched()：让出CPU时间片，重新等待安排任务

package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func(s string) {
        for i := 0; i < 2; i++ {
            fmt.Println(s)
        }
    }("world")
    // 主协程
    for i := 0; i < 2; i++ {
        // 切一下，再次分配任务
        runtime.Gosched()
        fmt.Println("hello")
    }
}

② runtime.Goexit()：退出当前协程

package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func() {
        defer fmt.Println(www.devze.com"A.defer")
        func() {
            defer fmt.Println("B.defer")
            // 结束协程
            runtime.Goexit()
            defer fmt.Println("C.defer")
            fmt.Println("B")
        }()
        fmt.Println("A")
    }()
    for {
    }
}

③ runtime.GOMAXPROCS：

Go运行时的调度器使用GOMAXPROCS参数来确定需要使用多少个OS线程来同时执行Go代码。默认值是机器上的CPU核心数。例如在一个8核心的机器上，调度器会把Go代码同时调度到8个OS线程上（GOMAXPROCS是m:n调度中的n）。

Go语言中可以通过runtime.GOMAXPROCS()函数设置当前程序并发时占用的CPU逻辑核心数。

Go1.5版本之前，默认使用的是单核心执行。Go1.5版本之后，默认使用全部的CPU逻辑核心数。

可以通过将任务分配到不同的CPU逻辑核心上实现并行的效果

func a() {
    for i := 1; i < 10; i++ {
        fmt.Println("A:", i)
 编程客栈   }
}

func b() {
    for i := 1; i < 10; i++ {
        fmt.Println("B:", i)
    }
}

func main() {
    runtime.GOMAXPROCS(1)
    go a()
    go b()
    time.Sleep(time.Second)
}

两个任务只有一个逻辑核心，此时是做完一个任务再做另一个任务。 将逻辑核心数设为2，此时两个任务并行执行，代码如下。

func a() {
    for i := 1; i < 10; i++ {
        fmt.Println("A:", i)
    }
}

func b() {
    for i := 1; i < 10; i++ {
        fmt.Println("B:", i)
    }
}

func main() {
    runtime.GOMAXPROCS(2)
    go a()
    go b()
    time.Sleep(time.Second)
}

二、底层设计：

Go语言的高效与简洁，离不开其运行时环境。runtime包作为Go语言运行时系统的核心接口，承载着内存管理、协程调度、垃圾回收、类型信息处理等关键功能。深入理解runtime包的底层设计，可以深入了解Go语言的运行机制。

1、内存管理与垃圾回收的底层协作

① 内存分配策略

runtime包中的内存分配器采用分层设计，分为线程缓存（Thread Cache）、中心缓存（Central Cache）和堆（Heap）三个层级：

• 线程缓存：每个Go线程拥有独立的线程缓存，用于快速分配小对象（通常小于16字节），避免频繁访问全局资源，减少锁竞争；

• 中心缓存：作为线程缓存的补充，负责从堆中获取大块内存，并切割成适合线程缓存的小块，平衡各线程间的内存使用；

• 堆：内存分配的最终来源，由垃圾回收器统一管理，当线程缓存和中心缓存无法满足需求时，直接从堆中分配内存 。

② 垃圾回收协同工作

垃圾回收器（GC）与内存分配器紧密配合，runtime包通过一系列函数控制GC的行为，如runtime.GC()可手动触发垃圾回收。在GC过程中：

• 标记阶段：从根对象（如全局变量、栈上变量）出发，标记所有可达对象；

• 清除阶段：回收未被标记的对象，将其占用的内存归还到空闲列表；

• 整理阶段（可选）：在特定情况下，对堆内存进行整理，减少内存碎片 。

2、协程调度的底层实现细节

runtime包是协程调度的核心执行者，基于M:N调度模型实现高效的协程调度：

• Goroutine（G）：用户态的轻量级线程，是Go语言并发的基本单元；

• MAChine（M）：对应操作系统线程，负责执行Goroutine中的代码；

• Processor（P）：协程调度的关键组件，维护本地协程队列，绑定到M上以减少上下文切换开销。

调度过程中，runtime包通过以下机制确保协程高效运行：

• 本地队列优先：P优先从本地队列获取Goroutine执行，减少竞争；

• 工作窃取算法：当本地队列为空时，P从其他P的本地队列窃取Goroutine，均衡负载；

• 阻塞处理：当M执行的Goroutine发生阻塞（如I/O操作），M与P分离，P绑定到其他空闲M继续执行其他Goroutine，避免线程浪费 。

3、运行时类型信息与反射支持

runtime包管理着程序中所有类型的元数据，这些信息是反射功能的基础：

• 类型描述：通过结构体记录类型的大小、对齐方式、方法集合等信息，如rtype结构体存储类型的基本属性，itab结构体记录接口类型与具体实现类型的映射关系；

• 反射实现：reflect包依赖runtime包提供的类型信息，在运行时动态获取对象的类型、调用方法、修改属性 。

例如，在进行反射操作时，runtime包负责提供类型比较、方法查找等底层支持，确保反射操作的正确性和高效性。

4、runtime包与开发者实践

虽然runtime包的大部分功能在幕后自动运行，但开发者在某些场景下仍需关注其行为：

• 性能调优：通过runtime.GOMAXPROCS()设置处理器数量，优化协程调度效率；利用runtime/pprof包进行性能分析，定位内存泄漏、CPU瓶颈等问题；

• 特殊场景处理：在需要与操作系统深度交互时，使用runtime包提供的系统调用接口；在编写高性能程序时，通过runtime包的内存分配函数手动管理内存 。

总结 

到此这篇关于Go学习记录之runtime包深入解析的文章就介绍到这了,更多相关Go runtime包内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的编程客栈相关文章希望大家以后多多支持编程客栈(www.devze.com)！