go 语言并发编程中的同步机制包括：互斥锁（mutex），用于确保仅一个协程访问共享数据；读写锁（rwmutex），允许多个协程同时读取但仅一个协程写入共享数据；通道（channel），允许协程间通信；以及原子操作，用于并发安全地更新底层变量的值。这些机制对于避免竞争条件和死锁至关重要，有助于编写安全的并发代码。

Go 函数并发编程中的同步机制

在 Go 语言的并发编程中，同步机制对于协调并发执行的协程非常重要。本文将探讨 Go 语言中常用的同步机制，以及如何使用它们来编写安全的并发代码。

互斥锁（Mutex）

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

互斥锁是一个基本且强大的同步机制，用于确保只有一个协程可以访问共享数据。互斥锁可以使用 sync.Mutex 类型来创建和使用。

import (
    "sync"
    "fmt"
)

func main() {
    var count int
    var mu sync.Mutex

    // 使用协程并行增加计数器
    for i := 0; i < 1000; i++ {
        go func() {
            mu.Lock()
            count++
            mu.Unlock()
        }()
    }

    // 等待所有协程完成
    var wg sync.WaitGroup
    wg.Add(1000)
    go func() {
        wg.Wait()
        fmt.Println("最终计数器值：", count)
    }()

    wg.Wait()
}

读写锁（RWMutex）

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

读写锁是一种更高级别的同步机制，允许多个协程同时读取共享数据，但只有一个协程可以写入共享数据。读写锁可以使用 sync.RWMutex 类型创建和使用。

import (
    "sync"
    "fmt"
)

func main() {
    var data string
    var rwmu sync.RWMutex

    // 并行读写操作
    for i := 0; i < 1000; i++ {
        go func(i int) {
            rwmu.RLock()
            fmt.Printf("协程 %d: %s\n", i, data)
            rwmu.RUnlock()
        }(i)

        if i%100 == 0 {
            rwmu.Lock()
            data = fmt.Sprintf("数据更新 %d", i)
            rwmu.Unlock()
        }
    }

    var wg sync.WaitGroup
    wg.Add(1000)
    go func() {
        wg.Wait()
        rwmu.RLock()
        fmt.Println("最终数据：", data)
        rwmu.RUnlock()
    }()

    wg.Wait()
}

通道（Channel）

通道是一种允许协程间通信的同步机制。通道可以用于发送和接收数据，从而确保协程之间有序、安全的通信。

import (
    "fmt"
)

func main() {
    ch := make(chan int)

    // 发送方协程
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
        }
        close(ch)
    }()

    // 接收方协程
    for v := range ch {
        fmt.Println(v)
    }
}

原子操作

原子操作是一组并发安全的函数，用于更新底层变量的值。原子操作可以确保即使有多个协程同时访问该变量，也不会发生数据损坏。

import (
    "sync/atomic"
    "fmt"
)

func main() {
    var count int64

    // 使用原子操作递增计数器
    for i := 0; i < 1000; i++ {
        go func() {
            atomic.AddInt64(&count, 1)
        }()
    }

    // 等待所有协程完成
    var wg sync.WaitGroup
    wg.Add(1000)
    go func() {
        wg.Wait()
        fmt.Println("最终计数器值：", count)
    }()

    wg.Wait()
}

理解和熟练使用这些同步机制对于编写安全的和高效的并发代码至关重要。这将有助于避免并发编程中的常见问题，例如竞争条件和死锁。