go学习笔记 2025-02-25 阅读次数：14

如何保证多个 goroutine 对共享变量的并发安全？

在 Go 语言中，多个 Goroutine 同时对共享变量进行读写时，可能会导致竞态条件（Race Condition），从而引发数据不一致的问题。为了保证并发安全，可以采用以下几种方法：

1. 使用互斥锁（sync.Mutex）

• 互斥锁用于确保同一时刻只有一个 Goroutine 可以访问共享变量。

• 示例：

  package main
  
   import (
       "fmt"
       "sync"
   )
  
   var (
       counter int
       mutex   sync.Mutex
       wg      sync.WaitGroup
   )
  
   func increment() {
       mutex.Lock()
       counter++
       mutex.Unlock()
       wg.Done()
   }
  
   func main() {
       wg.Add(100)
       for i := 0; i < 100; i++ {
           go increment()
       }
       wg.Wait()
       fmt.Println("Counter:", counter) // 输出 100
   }

2. 使用读写锁（sync.RWMutex）

• 读写锁允许多个 Goroutine 同时读取共享变量，但写操作是独占的。
• 示例：

package main

import (
    "fmt"
    "sync"
)

var (
    counter int
    rwMutex sync.RWMutex
    wg      sync.WaitGroup
)

func read() {
    rwMutex.RLock()
    fmt.Println("Counter:", counter)
    rwMutex.RUnlock()
    wg.Done()
}

func write() {
    rwMutex.Lock()
    counter++
    rwMutex.Unlock()
    wg.Done()
}

func main() {
    wg.Add(200)
    for i := 0; i < 100; i++ {
        go write()
        go read()
    }
    wg.Wait()
}

3. 使用原子操作（sync/atomic）

• 对于简单的数值类型，可以使用原子操作来保证并发安全。
• 示例：

    package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

var (
    counter int64
    wg      sync.WaitGroup
)

func increment() {
    atomic.AddInt64(&counter, 1)
    wg.Done()
}

func main() {
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go increment()
    }
    wg.Wait()
    fmt.Println("Counter:", counter) // 输出 100
}

4. 使用通道（Channel）

• 通过通道可以在 Goroutine 之间安全地传递数据，避免直接访问共享变量。
• 示例：

  package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    ch := make(chan int, 1) // 创建一个缓冲为1的通道
    ch <- 0                // 初始化计数器

    wg.Add(100)
    for i := 0; i < 100; i++ {
        go func() {
            count := <-ch
            count++
            ch <- count
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println("Counter:", <-ch) // 输出 100
}

5. 使用sync.Map

• sync.Map是并发安全的键值对集合，适合在读多写少的场景中使用。
• 示例：

  package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map
    var wg sync.WaitGroup

    wg.Add(100)
    for i := 0; i < 100; i++ {
        go func(i int) {
            m.Store(i, i)
            wg.Done()
        }(i)
    }
    wg.Wait()

    m.Range(func(k, v interface{}) bool {
        fmt.Println("Key:", k, "Value:", v)
        return true
    })
}

总结

为了保证多个 Goroutine 对共享变量的并发安全，可以根据具体场景选择合适的方法：

• 简单的数值操作可以使用原子操作。
• 复杂的同步需求可以使用互斥锁或读写锁。
• 避免直接共享变量时，可以使用通道或sync.Map。
• 选择合适的方法可以使代码更高效且更易维护。

channel 的底层实现原理是什么？

Go 语言中的 channel 是基于 CSP（Communicating Sequential Processes）模型实现的，用于在不同 goroutine 之间进行通信和同步。其底层实现原理主要包括以下几个关键点：

1. 数据结构: Channel 在 Go 内部是由一个 hchan 结构体表示。该结构体包含了用于存储数据的环形缓冲区、用于同步的等待队列（sendq 和 recvq）以及用于保护数据结构的互斥锁（lock）。

2. 缓冲区: Channel 可以是带缓冲区的或无缓冲区的。带缓冲区的 channel 在发送数据时，如果缓冲区未满，数据会被放入缓冲区，而不需要立即等待接收者。无缓冲区的 channel 则要求发送者和接收者必须同时准备好，否则会阻塞。

3. 同步机制: 当缓冲区满或空时，发送或接收操作会阻塞，并将当前 goroutine 放入相应的等待队列（sendq 或 recvq）中。当条件满足时（如缓冲区有空闲空间或新数据到达），会唤醒等待的 goroutine。

4. 关闭操作: 关闭 channel 会标记 channel 为关闭状态，并唤醒所有等待的 goroutine，发送操作会 panic，接收操作会返回零值和标记表示 channel 已关闭。

5. 调度器集成: Go 的调度器会在 goroutine 阻塞或唤醒时进行调度，确保 goroutine 能够高效地在 channel 操作之间切换。

通过这些机制，Go 的 channel 实现了高效的 goroutine 间通信和同步。

GPM 调度模型

Go 语言的 GPM 模型是 Go 并发编程的核心，它由Goroutine、Processor和Machine三部分组成，用于高效地管理和调度并发任务。以下是 GPM 模型的详细介绍：

1. Goroutine（G）

• 轻量级的用户态线程，由 Go 运行时管理。
• 相比操作系统线程，Goroutine 的创建和切换开销更小。
• 通过go关键字启动，例如：go func() { ... }()。

2. Processor（P）

• 调度器执行的上下文，负责管理一组 Goroutine。
• 每个 P 都有一个本地队列（Local Queue），用于存放等待执行的 Goroutine。
• 默认情况下，Go 程序启动的 P 数量等于 CPU 核心数，可通过GOMAXPROCS调整。

3. Machine（M）

• 操作系统线程，负责执行 Goroutine。
• M 与 P 绑定，P 决定哪些 Goroutine 由 M 执行。
• M 的数量通常略大于 P 的数量，以处理阻塞操作（如系统调用）。

GPM 模型的调度机制

1. Goroutine 的创建：

   • 当一个 Goroutine 被创建时，它会优先放入当前 P 的本地队列。
   • 如果本地队列已满，Goroutine 会被放入全局队列（Global Queue）。

2. Goroutine 的执行：

   • P 从本地队列中取出 Goroutine，并将其分配给 M 执行。
   • 如果本地队列为空，P 会尝试从全局队列或其他 P 的本地队列中窃取 Goroutine。

3. 阻塞与解阻塞：

   • 如果 Goroutine 执行阻塞操作（如系统调用），M 会释放 P 并与 Goroutine 一起进入阻塞状态。
   • 当 Goroutine 解阻塞后，M 会尝试绑定一个空闲的 P，如果没有空闲 P，Goroutine 会被放入全局队列。

4. 调度器的主动调度：

   • Go 调度器会在特定情况下主动调度 Goroutine，例如：
     • Goroutine 主动调用runtime.Gosched()。
     • 系统监控线程（sysmon）发现长时间运行的 Goroutine。

GPM 模型的优势

• 高效：避免了操作系统线程的频繁切换，降低了并发编程的开销。
• 易用：开发者无需关心底层线程管理，只需使用go关键字启动 Goroutine。
• 灵活：通过 P 的数量调整并发度，适应不同的硬件和任务需求。

总结

GPM 模型是 Go 语言高并发的基石，它通过高效的调度机制和轻量级的 Goroutine，使 Go 程序能够轻松处理成千上万的并发任务。理解 GPM 模型有助于更好地编写高性能的并发程序。

GC 垃圾回收算法

Go 语言的垃圾回收（GC）算法基于三色标记清除算法（Tri-color Mark-and-Sweep），并进行了优化以最大限度地减少停顿时间（Stop-the-World, STW）。以下是 Go 垃圾回收器的关键点和工作机制：

1. 三色标记清除算法

• 三色标记：将对象分为三种颜色以跟踪其状态：
  • 白色：未访问可达的对象，表示为垃圾。
  • 灰色：已访问但尚未扫描的对象。
  • 黑色：已访问并扫描了其引用的对象。
• 标记阶段：
  • 从根对象开始，标记所有可达的对象（从白色变为灰色再到黑色）。
• 清除阶段：
  • 回收所有未标记白色的对象。

2. 并发垃圾回收

• Go 的 GC 是并发的，标记阶段可与程序同时运行，从而减少 STW 时间。

3. 写屏障

• 写屏障技术用于在垃圾回收期间追踪对象间的引用变化，确保在标记阶段标记新引用的对象。

4. 分代垃圾回收

• Go 的垃圾回收器虽然不是传统意义上的分代收集器，但其设计自然优化了年轻代（短生命周期）对象的回收。

5. 触发条件

• 堆增长：当堆内存增长到特定的阈值时，GC 会触发。
• 手动触发：开发者可以通过runtime.GC()手动触发 GC。
• 周期性检查：Go 运行时定期检查是否需要执行垃圾回收。

6. GC 调优

• 使用GOGC环境变量可以调整垃圾回收器的行为（分别控制触发的频率和强度）。
• 默认GOGC=100表示堆增长 100%就会再次触发 GC。

7. 监控 GC 性能

• Go 提供了 API 来监控和获取 GC 性能指标，比如runtime.ReadMemStats。
• 这些指标包括 GC 次数、总耗时和堆内存使用情况。

示例：监控 GC 性能

package main

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

func printGCStats() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("GC Cycles: %d\n", m.NumGC)
    fmt.Printf("GC Pause Total: %v\n", time.Duration(m.PauseTotalNs))
    fmt.Printf("Heap Alloc: %v bytes\n", m.HeapAlloc)
}

func main() {
    for i := 0; i < 10; i++ {
        s := make([]byte, 1024*1024) // 分配1MB内存
        _ = s
        printGCStats()
        time.Sleep(time.Second)
    }
}

总结

Go 的垃圾回收器在设计上通过并行和并发的标记清除机制，以及写屏障技术，优化了垃圾回收过程以最大限度减少程序停顿。对短生命周期对象的有效回收帮助提高了内存管理效率。了解并合理配置 GC 参数，可以进一步优化 Go 程序的性能，特别是在高负载或实时性要求较高的应用中。

context 应用以及场景

在 Go 语言中，context包用于在不同 Goroutine 之间传递请求范围的信息、取消信号和截止日期。它是处理并发编程中请求上下文管理的重要工具。以下是关于 Go 的context及其应用场景的详细说明：

1. 基本概念

• Context是 Go 语言中的一个接口，通常用于管理请求级别的状态，例如取消信号、截止日期和传递请求范围内的键值对。

2. Context 的类型

• **context.Background()**：
  • 最顶层的上下文，一般用于主函数、初始化和测试代码的默认上下文，永远不会被取消且没有值和截止日期。
• **context.TODO()**：
  • 当不确定要使用哪种 Context 或还没有数据时使用。即待决状态。
• **context.WithCancel(parent)**：
  • 返回子Context和CancelFunc。调用CancelFunc会通知子 Context 取消。
• **context.WithDeadline(parent, deadline)**：
  • 设置截止时间背景，超过这个时间后，Context 自动取消。
• **context.WithTimeout(parent, timeout)**：
  • 类似WithDeadline，但更方便指定超时时间。
• **context.WithValue(parent, key, val)**：
  • 生成一个带有键值对的子 Context，传递数据。

3. 应用场景

• 取消信号传递：
  • 在分布式系统中跨 API 边界传递取消通知，确保不再需要时终止请求。
• 处理超时请求：
  • 设置请求的截止时间，超时时自动取消请求以节省资源。
• 跨 Goroutine 传递值：
  • 保持请求链中上下文名称和数据的一致性，例如请求 ID、用户身份等。

4. Context 的使用示例

取消操作

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go func(ctx context.Context) {
        select {
        case <-ctx.Done():
            fmt.Println("Operation canceled")
        }
    }(ctx)

    time.Sleep(2 * time.Second)
    cancel() // 触发取消操作
    time.Sleep(1 * time.Second)
}

超时控制

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    select {
    case <-time.After(3 * time.Second):
        fmt.Println("Operation completed")
    case <-ctx.Done():
        fmt.Println("Operation timed out")
    }
}

传递值

package main

import (
    "context"
    "fmt"
)

func main() {
    ctx := context.WithValue(context.Background(), "key", "value")

    doSomething(ctx)
}

func doSomething(ctx context.Context) {
    if value, ok := ctx.Value("key").(string); ok {
        fmt.Println("Found value:", value)
    } else {
        fmt.Println("Key not found")
    }
}

5. 注意事项

• context应为请求域共享且易于取消，因此不建议将context作为结构体成员。
• 应谨慎使用context.WithValue，避免过度使用而导致代码的可读性下降。

总结

context在 Go 的并发编程和请求处理中提供了强大的功能，尤其在处理取消信号、超时控制以及在链路中各服务间传递信息时。通过合理地应用context，可以编写出更清晰、更高效的 Go 程序。

内存对齐

Go 语言中的内存对齐是为了优化内存访问速度，以满足硬件架构对数据存储的要求。对齐可以提升内存访问效率，减少 CPU 访问内存的次数。以下是关于 Go 内存对齐的详细说明：

内存对齐的基本概念

• 对齐原则：数据在内存中的地址应该是其所占字节数的倍数。例如，4 字节的int32应该存储在 4 的倍数的内存地址上。
• 对齐的好处：对齐可提高数据访问效率，因为在许多 CPU 架构中，未对齐的内存访问可能会导致性能问题。

Go 中的对齐规则

• Go 编译器会自动为变量分配内存并进行适当的对齐。
• 各类型的内存对齐要求如下：
  • bool和byte：1 字节对齐。
  • int16和uint16：2 字节对齐。
  • int32、uint32和float32：4 字节对齐。
  • int64、uint64、float64和complex64：8 字节对齐。
  • 指针与平台相关，通常是 8 字节对齐（在 64 位系统上）。

结构体中的内存对齐

• 结构体的内存布局依赖于它的字段顺序。编译器可能会在字段之间插入填充字节以保证对齐。
• 结构体的总尺寸通常是最大对齐基数的整数倍。

示例：结构体内存对齐

package main

import (
    "fmt"
    "unsafe"
)
``

type StructExample struct {
    a bool    // 1 byte
    b int32   // 4 bytes
    c float64 // 8 bytes
}

func main() {
    e := StructExample{}
    fmt.Println("Size of StructExample:", unsafe.Sizeof(e)) //
}

在这个示例中，StructExample的内存总大小为 16 字节，其中包含了填充字节，以满足float64的对齐需求。

提高内存利用率的技巧

• 优化字段顺序：通过调整结构体字段顺序，可以减少填充字节，优化内存使用。
• 从大到小排序字段：按字段的大小和对齐需求从大到小排序，以减少对齐填充。

示例：优化后的结构体

type OptimizedStruct struct {
    c float64 // 8 bytes
    b int32   // 4 bytes
    a bool    // 1 byte
}

func main() {
    e := OptimizedStruct{}
    fmt.Println("Size of OptimizedStruct:", unsafe.Sizeof(e)) // 输出12字节
}

手动对齐和unsafe包

• Go 的unsafe包提供了一些工具来帮助开发者理解和控制内存对齐：
  • unsafe.Alignof：获取类型的对齐要求。
  • unsafe.Sizeof：获取类型的大小。
  • unsafe.Offsetof：获取结构体字段的偏移量。

总结

内存对齐影响到程序的性能和内存使用效率。Go 语言通过其编译器自动处理内存的对齐要求，但了解这些机制能够帮助开发者写出内存表现更高效的代码，并在需要时对结构体进行优化以减少不必要的内存开销。

sync.Pool

sync.Pool是 Go 标准库中的一种内存池机制，用于缓存和重用临时对象以减少内存分配和垃圾回收的负担。以下是关于sync.Pool的详细说明及其应用场景：

1. 基本概念

• sync.Pool提供了一种临时对象的存储机制。
• 被设计为减少需要频繁创建和销毁的对象的内存分配成本。
• 适用于可以被重复使用但无需严苛管理生命周期的对象。

2. 工作原理

• 对象获取：通过Get方法，sync.Pool尝试返回缓存池中的一个对象。如果池子为空，则调用用户定义的New函数创建一个新的对象。
• 对象放回：通过Put方法，将对象放回池中以便重用。
• 对象既可以由get分配，也可以主动放回池中，允许被未来的get线程使用。
• sync.Pool中的对象在没有被其他引用持有时，可以在任意时刻被 GC 回收。

3. 特点

• sync.Pool不保证在多核环境中所有的放入对象都能被未来的Get获取。
• 池中的对象无活跃时，可能会被垃圾回收。

4. 应用场景

• 临时对象缓存：适用于创建销毁开销较大的对象，例如缓冲区、网络连接、数据库条目等。
• 降低 GC 压力：通过重用对象，降低垃圾回收压力及频率。

5. 使用示例

package main

import (
    "fmt"
    "sync"
)

func main() {
    var pool = sync.Pool{
        New: func() interface{} {
            fmt.Println("Creating new instance")
            return make([]byte, 1024) // 分配1KB的缓存
        },
    }

    // Get an instance from the pool
    instance := pool.Get().([]byte)
    fmt.Printf("Got instance of size: %d\n", len(instance))

    // Use the instance...

    // Put the instance back into the pool
    pool.Put(instance)

    // Get another instance
    anotherInstance := pool.Get().([]byte)
    fmt.Printf("Got another instance of size: %d\n", len(anotherInstance))
}

输出：

Creating new instance
Got instance of size: 1024
Got another instance of size: 1024

6. 最佳实践

• sync.Pool并非万能，不能用于需要严格管理的资源，特别是一些外部资源（如文件句柄、数据库连接）。
• 应用于只有短生命周期的可回收的轻量对象。
• 不要期望sync.Pool中的对象总是可以获取到，因为它们可能会被 GC。

总结

sync.Pool是一个简单且有效的工具，用于在多线程环境中使用并复用可缓存的对象。当适当使用时，它可以显著减少内存分配，提高性能。但因其设计为缓存而非长存储，使用时需要考虑对象容易被回收的特性

Worker Pool(工作池)

worker pool 模式是一种常见的并发编程技巧，用于限制并发 goroutine 的数量，从而提高系统性能和稳定性。它主要用于处理大量并发任务，避免因创建过多 goroutine 而导致资源耗尽。

工作原理

任务队列：

• 将需要执行的任务放入一个任务队列（通常是 channel）。

Worker goroutine：

• 创建一组 worker goroutine，它们从任务队列中获取任务并执行。
• worker goroutine 的数量通常是固定的，以控制并发度。

任务分发： - 将任务放入任务队列，worker goroutine 会自动从队列中获取任务并执行。 -结果处理（可选）： 可以使用 channel 或其他机制来收集 worker goroutine 的执行结果。

package main

import (
        "fmt"
        "sync"
        "time"
)

type Task struct {
        ID int
}

func worker(id int, tasks <-chan Task, wg *sync.WaitGroup) {
        defer wg.Done()
        for task := range tasks {
                fmt.Printf("Worker %d processing task %d\n", id, task.ID)
                time.Sleep(1 * time.Second) // 模拟任务执行
        }
}

func main() {
        numWorkers := 3
        numTasks := 10

        tasks := make(chan Task, numTasks)
        var wg sync.WaitGroup

        // 创建 worker goroutine
        for i := 1; i <= numWorkers; i++ {
                wg.Add(1)
                go worker(i, tasks, &wg)
        }

        // 分发任务
        for i := 1; i <= numTasks; i++ {
                tasks <- Task{ID: i}
        }
        close(tasks) // 关闭任务队列

        // 等待所有 worker goroutine 完成
        wg.Wait()
        fmt.Println("All tasks processed")
}

参考

digitalOcean: concurrency in go