go 语言中的锁机制和同步技术对于实现并发性至关重要。常用的锁机制包括：sync.mutex：互斥锁，一次只允许一个 goroutine 访问临界区。sync.rwmutex：读写锁，允许多个 goroutine 同时读，但一次只能有一个 goroutine 写。sync.cond：条件变量，用于等待或通知其他 goroutine。

Go 语言中的锁机制与同步技术

在 Go 语言中，锁和同步原语对于实现并发性和防止竞争至关重要。本文将探索 Go 语言提供的不同锁机制和同步技术，并提供实际示例说明其用法。

锁机制

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

Go 语言中常用的锁机制有：

• sync.Mutex: 互斥锁，一次只允许一个 goroutine 访问临界区。
• sync.RWMutex: 读写锁，允许多个 goroutine 同时读，但一次只能有一个 goroutine 写。
• sync.Cond: 条件变量，用于等待或通知其他 goroutine。

实战示例

使用 sync.Mutex 保护临界区

package main

import (
    "fmt"
    "sync"
)

var m sync.Mutex
var count int

func increment() {
    m.Lock()
    defer m.Unlock()
    count++
}

func main() {
    go increment()
    go increment()
    go increment()

    fmt.Println(count) // 输出：3
}

在示例中，我们使用互斥锁 m 保护临界区，确保每次只有一个 goroutine 可以更新 count 变量。

使用 sync.RWMutex 允许多个读

package main

import (
    "fmt"
    "sync"
)

var m sync.RWMutex
var count int

func read() {
    m.RLock()
    defer m.RUnlock()
    fmt.Println(count)
}

func write() {
    m.Lock()
    defer m.Unlock()
    count++
}

func main() {
    go read()
    go read()
    go write()

    fmt.Println(count) // 输出：1
}

在示例中，我们使用读写锁 m，允许多个 goroutine 同时读取 count 变量，但只能有一个 goroutine 写入。

使用 sync.Cond 等待和通知

package main

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

var m sync.Mutex
var cond sync.Cond
var done bool

func worker() {
    m.Lock()
    for !done {
        cond.Wait(&m)
    }
    m.Unlock()
    fmt.Println("Worker done")
}

func main() {
    go worker()

    time.Sleep(time.Second)
    m.Lock()
    done = true
    cond.Signal()
    m.Unlock()

    fmt.Println("Main done")
}

在示例中，我们使用条件变量 cond 等待 done 为 true，然后通知等待的 goroutine。