go 函数并发编程使用锁需注意:避免死锁:正确获取和释放锁。避免竞态条件:仅在获取锁后修改共享数据。考虑锁的粒度:细粒度锁并发性高但开销大。使用 rwmutex 实现读写锁:并发读取,独占写入。
Go 函数并发编程的锁使用注意事项
Go 中的并发编程依赖于锁来保证并发安全和数据完整性。使用锁时需要注意以下事项:
1. 避免死锁
立即学习“go语言免费学习笔记(深入)”;
死锁是指两个或多个 goroutine 由于等待锁而无限期地阻塞。避免死锁的常见方法是:
// 使用锁的正确方式:先获取锁,再执行操作
mu.Lock()
defer mu.Unlock()
... // 执行操作
2. 避免竞态条件
竞态条件是指对共享数据进行多个并行访问,导致不可预期的结果。要避免竞态条件,请确保以下一项为真:
- 只有一个 goroutine 在任何给定时间获取锁。
- 共享数据仅在获取锁后修改。
例如:
// 使用锁防止竞态条件:仅当持有锁时才修改共享数据
var count int
func incrementCount() {
mu.Lock()
defer mu.Unlock()
count++
}
3. 考虑锁的粒度
锁的粒度决定了它们控制的代码范围。较粗粒度的锁保护更大的代码段,从而减少了并发的机会。较细粒度的锁提供更高程度的并发,但会增加开销。
4. 使用 RWMutex 实现读写锁
RwMutex 是一种特殊的锁,允许并发的读取操作,但写入操作需要独占锁定。这提高了并发性,同时保持了写入操作的数据完整性。
例如:
type Counter struct {
mu sync.RWMutex
count int
}
func (c *Counter) Increment() {
c.mu.Lock()
defer c.mu.Unlock()
c.count++
}
func (c *Counter) Read() int {
c.mu.RLock()
defer c.mu.RUnlock()
return c.count
}
实战案例
以下是一个使用锁的并发缓存的示例:
package main
import (
"sync"
)
type Cache struct {
mu sync.Mutex
items map[string]string
}
func (c *Cache) Get(key string) (string, bool) {
c.mu.Lock()
defer c.mu.Unlock()
val, ok := c.items[key]
return val, ok
}
func (c *Cache) Set(key, value string) {
c.mu.Lock()
defer c.mu.Unlock()
c.items[key] = value
}
func main() {
// 创建并发缓存
cache := &Cache{
mu: sync.Mutex{},
items: make(map[string]string),
}
// 并发地向缓存添加和获取项
go cache.Set("foo", "bar")
val, ok := cache.Get("foo")
if ok {
println(val) // 输出 "bar"
}
}