golang多协程加锁

在并发编程中，锁是一个重要的概念。Golang是一门拥有强大并发支持的编程语言，通过goroutine和channel，开发者可以轻松地编写并发程序。然而，在多个goroutine同时访问共享资源的情况下，就会出现数据竞争的问题。为了解决这个问题，我们可以使用多协程加锁的方式来确保数据的安全性。

互斥锁

在Golang中，最常用的锁是互斥锁（Mutex）。互斥锁是一个二元信号量，表示一个资源被占用。只有持有互斥锁的goroutine才能访问该资源，其他goroutine需要等待直到该资源被释放。下面是一个使用互斥锁的例子：

import (
    "sync"
    "fmt"
)

var mutex sync.Mutex
var count int

func main() {
    // 启动10个goroutine并发递增count
    for i := 0; i < 10; i++ {
        go increment()
    }

    // 等待所有goroutine执行完毕
    time.Sleep(time.Second)

    fmt.Println("count:", count)
}

func increment() {
    mutex.Lock() // 加锁
    defer mutex.Unlock() // 解锁

    count++
}

读写锁

互斥锁适用于多个goroutine读写不频繁的场景。但在多个goroutine频繁读写同一个资源的情况下，互斥锁的性能会比较低。这时可以使用读写锁（RWMutex）来提升性能。

import (
    "sync"
    "fmt"
)

var rwMutex sync.RWMutex
var count int

func main() {
    // 启动10个goroutine并发递增count
    for i := 0; i < 10; i++ {
        go increment()
    }

    // 等待所有goroutine执行完毕
    time.Sleep(time.Second)

    fmt.Println("count:", count)
}

func increment() {
    rwMutex.Lock() // 写锁
    defer rwMutex.Unlock() // 解锁

    count++
}

func getCount() int {
    rwMutex.RLock() // 读锁
    defer rwMutex.RUnlock() // 解锁

    return count
}

条件变量

互斥锁和读写锁可以解决大部分的并发问题，但有时候我们希望goroutine能够根据某些条件等待或唤醒特定的信号。这时我们可以使用条件变量（Cond）。

import (
    "sync"
    "fmt"
)

var mutex sync.Mutex
var cond *sync.Cond
var ready bool

func main() {
    mutex.Lock()
    cond = sync.NewCond(&mutex) // 创建条件变量

    go waitForSignal()
    time.Sleep(time.Second)

    ready = true
    cond.Signal() // 发送信号

    mutex.Unlock()
    time.Sleep(2 * time.Second)
}

func waitForSignal() {
    mutex.Lock()
    for !ready {
        cond.Wait() // 等待信号
    }
    fmt.Println("Received signal")
    mutex.Unlock()
}

通过使用互斥锁、读写锁和条件变量，我们可以在Golang中实现多协程的加锁机制，确保共享资源的安全性。不过，在使用锁的时候要谨慎，过多的锁会带来性能问题，因此需要根据具体场景选择合适的锁。