当前位置：首页 > news >正文

Golang笔记——常用库context和runtime

news 文章来源：https://blog.csdn.net/haopingbiji/article/details/145379179 2025/4/29 9:00:05

大家好，这里是Good Note，关注公主号：Goodnote，专栏文章私信限时Free。本文详细介绍Golang的常用库context和runtime，包括库的基本概念和基本函数的使用等。

在这里插入图片描述

文章目录

- context
- - `context` 包的基本概念
  - 主要类型和函数
  - - 1. **`Context` 类型**
    - 2. **`context.Background()` 和 `context.TODO()`**
    - 示例：
    - 3. **`context.WithCancel()`**
    - 语法：
    - 示例：
    - 4. **`context.WithTimeout()` 和 `context.WithDeadline()`**
    - 语法：
    - 示例：
    - 5. **`context.WithValue()`**
    - 语法：
    - 示例：
  - 组合使用 `context` 的常见场景
  - `context` 与 goroutine
  - - 示例：goroutine 中使用上下文取消操作
  - 总结
- runtime
- - 1. `runtime` 包功能概述
  - 2. 常用函数和用途
  - - 2.1 Goroutine 管理
    - 2.2 内存管理与垃圾回收
    - 2.3 并发控制
    - 2.4 调用栈和错误处理
    - 2.5 程序环境与操作系统信息
    - 2.6 Cgo 和与 C 交互
  - 3. `runtime.MemStats` 结构体
  - 4. 开发中的常见应用场景
  - - 4.1 性能监控和调优
    - 4.2 内存泄漏排查
    - 4.3 多核 CPU 优化
    - 4.4 调试与异常处理
    - 4.5 跨平台开发
  - 5. 总结
- 历史文章
- - MySQL数据库
  - Redis
  - Golang

context

Go 语言中的 context 包是一个用于处理跨 API 边界、跨多个 goroutine 的请求上下文的标准库。它提供了一种传递上下文信息、取消信号和超时机制的方式，特别适用于并发程序设计中。在 Go 中，context 主要用于：

取消信号传递：在多个 goroutine 中传递取消信号。
超时控制：控制操作的超时。
传递请求范围的数据：将请求级别的数据（如请求 ID）传递到不同的 goroutine。

`context` 包的基本概念

context 的核心概念是通过一个 Context 对象在不同的 goroutine 之间传递数据，取消信号和超时信息。Context 是一个接口，通常用于传递一些可以取消的、具有超时限制的共享数据。

context 包的常见用途包括：

在 HTTP 请求处理、数据库查询、RPC 调用中传递上下文。
管理 goroutine 生命周期：当主操作需要取消时，通过上下文通知相关 goroutine。

主要类型和函数

1. `Context` 类型

context.Context 是一个接口，定义了处理上下文的基本方法。它的实现包含了不同的上下文实例，如背景上下文（background）、请求上下文（WithCancel、WithTimeout、WithDeadline 等）。

接口定义：

type Context interface {Deadline() (deadline time.Time, ok bool)  // 获取截止时间Done() <-chan struct{}                     // 获取取消信号Err() error                                // 返回取消的原因Value(key interface{}) interface{}         // 获取与指定 key 相关联的值
}

2. `context.Background()` 和 `context.TODO()`

这两个函数是获取根上下文的方式：

context.Background()：通常作为主程序的起点或者初始化根上下文。它通常用于 main 函数、初始化以及测试中。
context.TODO()：类似于 Background()，但用于代码尚未决定使用何种上下文的地方。通常在代码中预留，用于以后需要添加上下文的地方。

示例：

package mainimport ("context""fmt"
)func main() {// 使用 context.Background()ctx := context.Background()fmt.Println("Background context:", ctx)
}

3. `context.WithCancel()`

WithCancel 用于创建一个带取消功能的子上下文。当调用父上下文的取消函数时，子上下文的 Done 通道会接收到信号。

语法：

func WithCancel(parent Context) (ctx Context, cancel func())

parent：父上下文。
ctx：返回的子上下文。
cancel：调用此函数会取消子上下文。

示例：

package mainimport ("context""fmt""time"
)func main() {// 创建带取消功能的上下文ctx, cancel := context.WithCancel(context.Background())// 模拟在 goroutine 中使用上下文go func() {select {case <-ctx.Done():fmt.Println("Context cancelled")}}()// 取消上下文time.Sleep(2 * time.Second)cancel()  // 取消上下文，触发 goroutine 中的 Done 通道
}

4. `context.WithTimeout()` 和 `context.WithDeadline()`

WithTimeout 和 WithDeadline 用于创建带有超时和截止时间的上下文。

WithTimeout：设置超时时间，超时后会自动取消上下文。
WithDeadline：设置具体的截止时间，超出截止时间后会自动取消上下文。

语法：

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)

WithTimeout 使用相对时间，指定超时的时长。
WithDeadline 使用绝对时间，指定具体的截止时间。

示例：

package mainimport ("context""fmt""time"
)func main() {// 使用 WithTimeout 设置超时ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)defer cancel()// 模拟处理任务select {case <-time.After(2 * time.Second):fmt.Println("Task completed")case <-ctx.Done():fmt.Println("Context cancelled:", ctx.Err())}
}

在这个示例中，任务会在超时 3 秒后自动取消，如果 time.After 中的延迟超过了超时时间，ctx.Done() 将会接收到取消信号。

5. `context.WithValue()`

WithValue 用于将特定的数据与上下文关联。可以在上下文中存储键值对，以便跨 goroutine 传递数据。

语法：

func WithValue(parent Context, key, val interface{}) Context

key 和 val 是用户定义的键值对，可以在之后的代码中通过 context.Value() 获取。

示例：

package mainimport ("context""fmt"
)func main() {// 创建上下文并设置键值对ctx := context.WithValue(context.Background(), "userID", 12345)// 从上下文中获取值userID := ctx.Value("userID")fmt.Println("UserID:", userID)
}

这里的 WithValue 可以用于传递诸如请求 ID、用户信息等上下文数据。

组合使用 `context` 的常见场景

处理请求超时：在 HTTP 请求处理中，可以使用 WithTimeout 或 WithDeadline 来限制请求的最长处理时间，防止请求挂起太长时间。
取消信号传递：可以通过 WithCancel 来创建一个带取消功能的上下文，将取消信号传递给多个 goroutine，确保在操作超时或取消时，所有相关的 goroutine 都能够及时退出。
在多个 goroutine 中传递共享数据：使用 WithValue 在上下文中传递请求级别的数据（如请求 ID、用户认证信息等），从而可以在多个 goroutine 中共享这些数据。

`context` 与 goroutine

context 在并发编程中尤其重要。当你启动一个 goroutine 时，可以传递一个上下文，允许在执行过程中传递取消信号或超时信号。通过上下文，你可以确保在程序需要取消某个操作时，能够优雅地停止相关的 goroutine。

示例：goroutine 中使用上下文取消操作

package mainimport ("context""fmt""time"
)func doWork(ctx context.Context) {select {case <-time.After(5 * time.Second):fmt.Println("Work completed")case <-ctx.Done():fmt.Println("Work canceled:", ctx.Err())}
}func main() {// 创建一个 2 秒超时的上下文ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)defer cancel()// 启动 goroutine 执行任务go doWork(ctx)// 等待 goroutine 完成time.Sleep(3 * time.Second)
}

在这个例子中，doWork 函数中的 goroutine 会在超时后被取消，ctx.Done() 会接收到取消信号，停止工作。

总结

context 包是 Go 语言中用于处理并发操作和跨 goroutine 传递信息的重要工具。
通过上下文，可以传递取消信号、超时控制、以及请求范围的数据。
常用函数包括 WithCancel、WithTimeout、WithDeadline 和 WithValue。
context 包的设计帮助开发者在并发场景中管理 goroutine 生命周期，尤其在网络请求、数据库操作等中具有重要作用。

通过合理使用 context，你可以在并发编程中更好地管理 goroutine、取消操作以及控制超时，确保程序的健壮性。

runtime

runtime 包是 Go 语言的一个核心库，它提供了与 Go 运行时系统交互的接口，包括并发调度、内存管理、垃圾回收、调用栈信息、程序环境信息等。开发中，runtime 包非常有用，特别是在调试、性能调优、并发控制等场景下。

在实际开发中，通常使用 runtime 包来：

获取内存使用统计信息，了解内存分配、垃圾回收情况。
调试时获取 goroutine 调度信息，帮助定位性能瓶颈。
管理并发，通过 GOMAXPROCS 调整使用的 CPU 核心数。
跨平台开发，根据操作系统和架构类型进行条件编译。
控制程序退出，通过 Goexit() 或调度器管理 goroutine。

下面是更加详细的介绍：

1. `runtime` 包功能概述

runtime 包包含对 Go 语言运行时系统的控制。Go 程序的运行时系统负责管理协程（goroutines）、垃圾回收（GC）、内存分配、调度等任务。runtime 包提供的函数和类型使得开发者能够在运行时获取程序的状态、控制并发、监控内存使用等。

2. 常用函数和用途

2.1 Goroutine 管理

Go 使用 goroutine 来实现轻量级的并发。在开发中，我们通常需要获取 goroutine 的状态，或者控制并发的数量。

Goexit：强制终止当前 goroutine。用在程序错误或需要提前退出的场景。
```
runtime.Goexit()  // 终止当前 goroutine，其他 goroutines 不受影响
```
这在协程出错或执行某个任务完成时尤其有用。
NumGoroutine：获取当前正在执行的 goroutine 数量。
```
num := runtime.NumGoroutine()
fmt.Println(num)  // 输出当前运行的 goroutine 数量
```
在高并发应用中，使用 NumGoroutine 来检查当前系统的负载（即 goroutines 数量），特别是在对性能进行调优时非常有用。

2.2 内存管理与垃圾回收

Go 使用垃圾回收（GC）机制自动管理内存分配和回收。runtime 包可以提供关于内存使用的详细信息。

MemStats：获取内存统计信息。通过这个函数，你可以了解内存的分配情况，例如已分配内存、GC 使用的内存等。

var m runtime.MemStats
runtime.ReadMemStats(&m)fmt.Println("Alloc:", m.Alloc)          // 当前堆内存使用量
fmt.Println("TotalAlloc:", m.TotalAlloc) // 程序总共分配的内存量
fmt.Println("HeapAlloc:", m.HeapAlloc)  // 堆内存分配的量
fmt.Println("HeapSys:", m.HeapSys)      // 堆内存系统分配的量
fmt.Println("NumGC:", m.NumGC)          // 垃圾回收次数

开发中，如果需要跟踪程序的内存使用情况或进行内存泄漏排查，可以使用这个函数来了解内存的分配和回收情况。

GC：强制触发垃圾回收。一般情况下，Go 的垃圾回收是自动触发的，但是有时我们可能需要手动触发垃圾回收，来进行性能测试或控制内存回收的时机。
```
runtime.GC()  // 强制执行垃圾回收
```
通常，Go 的 GC 是在程序空闲时自动执行，但在性能敏感的应用中，开发者可以使用 runtime.GC() 来控制垃圾回收的时机。

2.3 并发控制

Go 中的并发是通过 goroutine 和调度器来管理的，runtime 包提供了控制并发和获取调度信息的接口。

GOMAXPROCS：设置 Go 程序使用的最大 CPU 核心数。默认情况下，Go 程序会使用系统所有的 CPU 核心，使用 GOMAXPROCS 可以手动设置。
```
runtime.GOMAXPROCS(4)  // 设置最大 CPU 核心数为 4
```
这对于程序的并发性能调优很有帮助，尤其是在 CPU 密集型任务中。

2.4 调用栈和错误处理

Caller：获取调用栈的信息。runtime.Caller() 函数可以帮助我们获取当前函数的调用栈信息。通常用于调试和错误日志中。
```
pc, file, line, ok := runtime.Caller(0)
fmt.Printf("PC: %v, File: %v, Line: %v, OK: %v\n", pc, file, line, ok)
```
Caller(0) 返回当前函数的调用信息，Caller(1) 返回上一层函数的信息，依此类推。
Stack：获取当前 goroutine 的调用栈。通常用于调试和排查程序崩溃的问题。
```
buf := make([]byte, 1024)
n := runtime.Stack(buf, false)
fmt.Println(string(buf[:n]))
```
Stack 方法可以打印当前 goroutine 的调用栈，帮助开发者排查程序在运行时的异常。

2.5 程序环境与操作系统信息

GOARCH：获取当前操作系统架构（如 amd64、arm）。
```
fmt.Println(runtime.GOARCH)  // 输出：amd64
```
GOOS：获取当前操作系统类型（如 linux、windows、darwin 等）。
```
fmt.Println(runtime.GOOS)    // 输出：linux
```

这些信息对于编写跨平台的应用非常有用，尤其是在需要根据平台做不同处理时。

2.6 Cgo 和与 C 交互

Go 语言通过 cgo 与 C 代码进行交互，runtime 包也提供了相关的接口。

CgoCall：该函数用于处理 C 语言和 Go 语言之间的调用，虽然在实际开发中不常用，但对于编写需要与 C 库交互的代码时，runtime 包是必不可少的。

3. `runtime.MemStats` 结构体

runtime.MemStats 是 Go 语言用于描述内存使用的结构体，常用字段有：

Alloc：当前分配的堆内存字节数。
TotalAlloc：程序运行过程中总共分配的内存字节数。
HeapAlloc：当前堆内存分配的字节数。
HeapSys：堆内存分配给 Go 程序的总字节数。
HeapIdle：当前堆内存中未使用的字节数。
NumGC：垃圾回收的次数。
PauseTotalNs：所有垃圾回收的总暂停时间。

通过 runtime.ReadMemStats 函数可以获取这些内存统计信息，帮助开发者分析程序的内存使用情况，进行内存优化。

4. 开发中的常见应用场景

4.1 性能监控和调优

在高并发或资源密集型应用中，开发者常常需要监控 CPU 和内存的使用情况，以便进行性能调优。例如，可以通过 runtime.NumGoroutine() 监控 goroutine 的数量，使用 runtime.ReadMemStats() 监控内存使用情况。

4.2 内存泄漏排查

通过 runtime.MemStats，开发者可以查看程序的内存分配和垃圾回收情况。如果程序的内存占用不断上升，可能是内存泄漏的表现。通过 runtime.GC() 和 runtime.ReadMemStats()，可以帮助发现内存泄漏并进行优化。

4.3 多核 CPU 优化

在多核机器上，Go 默认会利用多个 CPU 核心来并行执行程序。通过设置 runtime.GOMAXPROCS()，开发者可以控制使用的最大 CPU 核心数，进行并发优化。

4.4 调试与异常处理

runtime.Stack() 和 runtime.Caller() 在调试时非常有用，帮助开发者捕获栈信息并定位错误。开发者可以在错误发生时打印调用栈信息，便于分析和修复问题。

4.5 跨平台开发

使用 runtime.GOARCH 和 runtime.GOOS，可以根据不同的操作系统和架构编写不同的代码，适配不同的运行环境。

5. 总结

runtime 包是 Go 语言中非常重要

的一个工具库，提供了与 Go 运行时系统交互的各种接口。开发中，runtime 包广泛应用于性能调优、并发管理、内存监控、跨平台开发等领域。掌握 runtime 包的使用，能够帮助开发者更好地理解 Go 语言的执行机制，并对程序进行高效调试和优化。

历史文章

MySQL数据库

Redis

Redis数据库笔记合集

Golang

Golang笔记——语言基础知识
Golang笔记——切片与数组
Golang笔记——hashmap
Golang笔记——rune和byte
Golang笔记——channel
Golang笔记——Interface类型
Golang笔记——数组、Slice、Map、Channel的并发安全性
Golang笔记——协程同步
Golang笔记——并发控制
Golang笔记——GPM调度器
Golang笔记—— new() 、 make() 和简短声明符
Golang笔记—— error 和 panic
Golang——内存（内存管理、内存逃逸、垃圾回收 (GC) 机制）
Golang笔记——包的循环引用问题(import cycle not allowed)和匿名导入
Golang笔记——常用库sync