Golang笔记——常用库context和runtime

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

context

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

1. 取消信号传递：在多个 goroutine 中传递取消信号。
2. 超时控制：控制操作的超时。
3. 传递请求范围的数据：将请求级别的数据（如请求 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 main

import (
"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 main

import (
"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 main

import (
"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 main

import (
"context"
"fmt"
)

func main() {
// 创建上下文并设置键值对
ctx := context.WithValue(context.Background(), "userID", 12345)

// 从上下文中获取值
userID := ctx.Value("userID")
fmt.Println("UserID:", userID)
}

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

组合使用 context 的常见场景

1. 处理请求超时：在 HTTP 请求处理中，可以使用 WithTimeout 或 WithDeadline 来限制请求的最长处理时间，防止请求挂起太长时间。

2. 取消信号传递：可以通过 WithCancel 来创建一个带取消功能的上下文，将取消信号传递给多个 goroutine，确保在操作超时或取消时，所有相关的 goroutine 都能够及时退出。

3. 在多个 goroutine 中传递共享数据：使用 WithValue 在上下文中传递请求级别的数据（如请求 ID、用户认证信息等），从而可以在多个 goroutine 中共享这些数据。

context 与 goroutine

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

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

package main

import (
"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数据库

MySQL数据库

Redis

Redis数据库笔记合集

Golang

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

原文地址：https://blog.csdn.net/haopingbiji/article/details/145201561

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！