golang 的 sync 包通过 mutex 和 rwmutex 实现线程安全。1. mutex 提供互斥锁，确保同一时间仅一个 goroutine 访问资源；2. rwmutex 提供读写锁，允许多个 goroutine 同时读，但写操作独占；3. 根据读写比例选择锁类型，读多用 rwmutex，否则用 mutex；4. 避免死锁需保持锁顺序一致、避免锁内调用外部函数、使用超时机制；5. 使用 -race 标志检测数据竞争；6. 其他并发工具包括 waitgroup、once、cond 和 atomic 包。正确选择和使用这些工具可实现高效可靠的并发控制。
用 Golang 的
sync包实现线程安全，核心在于控制对共享资源的访问。
Mutex提供互斥锁，保证同一时间只有一个 goroutine 可以访问资源；
RWMutex提供读写锁，允许多个 goroutine 同时读，但写操作会独占资源。选择哪种锁，取决于你的应用场景。
解决方案
sync包是 Golang 中实现并发控制的关键。
Mutex和
RWMutex是其中最常用的工具，它们分别提供了互斥锁和读写锁的功能，帮助我们编写线程安全的代码。
Mutex (互斥锁)
立即学习“go语言免费学习笔记（深入）”；
Mutex的核心思想是“互斥”，即同一时刻只允许一个 goroutine 访问被保护的资源。使用
Mutex非常简单，只需要调用
Lock()方法加锁，
Unlock()方法解锁。
package main
import (
"fmt"
"sync"
"time"
)
type Counter struct {
mu sync.Mutex
value int
}
func (c *Counter) Increment() {
c.mu.Lock()
defer c.mu.Unlock() // 确保函数退出时解锁
c.value++
}
func (c *Counter) Value() int {
c.mu.Lock()
defer c.mu.Unlock()
return c.value
}
func main() {
counter := Counter{}
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
counter.Increment()
}()
}
wg.Wait()
fmt.Println("Counter:", counter.Value()) // 输出：Counter: 1000
}在这个例子中，
Counter结构体包含一个
Mutex和一个整数
value。
Increment()方法用于增加计数器的值，
Value()方法用于获取计数器的值。两个方法都使用了
Lock()和
Unlock()来保护
value变量，确保并发访问时不会出现数据竞争。
defer c.mu.Unlock()是一种良好的实践，它可以确保在函数退出时总是释放锁，即使函数发生了 panic。
RWMutex (读写锁)
RWMutex是对
Mutex的一种扩展，它允许多个 goroutine 同时读取共享资源，但只允许一个 goroutine 写入共享资源。
RWMutex提供了
RLock()(读锁) 和
RUnlock()(读解锁) 方法用于读取操作，
Lock()和
Unlock()方法用于写入操作。
package main
import (
"fmt"
"sync"
"time"
)
type Data struct {
mu sync.RWMutex
value map[string]int
}
func (d *Data) Read(key string) int {
d.mu.RLock()
defer d.mu.RUnlock()
return d.value[key]
}
func (d *Data) Write(key string, value int) {
d.mu.Lock()
defer d.mu.Unlock()
d.value[key] = value
}
func main() {
data := Data{value: make(map[string]int)}
var wg sync.WaitGroup
// 模拟多个读操作
for i := 0; i < 10; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
time.Sleep(time.Duration(i) * time.Millisecond) // 模拟不同的读取延迟
fmt.Printf("Reader %d: Value for key 'test' is %d\n", i, data.Read("test"))
}(i)
}
// 模拟一个写操作
wg.Add(1)
go func() {
defer wg.Done()
time.Sleep(5 * time.Millisecond) // 稍微等待，确保读操作先执行
data.Write("test", 123)
fmt.Println("Writer: Updated value for key 'test'")
}()
wg.Wait()
}在这个例子中，
Data结构体包含一个
RWMutex和一个
map。
Read()方法使用
RLock()和
RUnlock()来保护读取操作，允许多个 goroutine 同时读取
map。
Write()方法使用
Lock()和
Unlock()来保护写入操作，确保只有一个 goroutine 可以修改
map。
选择 Mutex 还是 RWMutex？
选择
Mutex还是
RWMutex取决于你的应用场景。如果你的程序中读操作远多于写操作，那么使用
RWMutex可以提高程序的并发性能。反之，如果读写操作的比例接近，或者写操作非常频繁，那么使用
Mutex可能更简单高效。实际上，
RWMutex在写操作时性能会略低于
Mutex，因为需要维护读写锁的状态。
如何避免死锁？
死锁是并发编程中常见的问题，它指的是两个或多个 goroutine 互相等待对方释放锁，导致程序无法继续执行。避免死锁的关键在于避免循环依赖。以下是一些避免死锁的常见技巧：
- 锁的顺序一致性： 如果多个 goroutine 需要同时获取多个锁，确保它们以相同的顺序获取锁。
- 避免持有锁时调用外部函数： 在持有锁时调用外部函数可能会导致死锁，因为外部函数可能会尝试获取相同的锁。
- 使用超时机制： 在尝试获取锁时设置超时时间，如果超过超时时间仍然无法获取锁，则放弃获取，避免一直阻塞。
-
使用
go vet
工具：go vet
工具可以帮助你检测代码中潜在的死锁问题。
如何检测数据竞争？
数据竞争指的是多个 goroutine 同时访问和修改同一个共享变量，并且至少有一个 goroutine 是写入操作，这会导致程序出现不可预测的行为。Golang 提供了
-race标志来检测数据竞争。在编译或运行程序时，加上
-race标志，
go工具链会自动检测代码中是否存在数据竞争，并输出详细的报告。
go run -race main.go
如果程序存在数据竞争，
go工具链会输出类似于以下的报告：
==================
WARNING: DATA RACE
Write at 0x00c0000a2000 by goroutine 7:
main.Counter.Increment()
/path/to/your/code/main.go:15 +0x45
Previous write at 0x00c0000a2000 by goroutine 6:
main.Counter.Increment()
/path/to/your/code/main.go:15 +0x45
Goroutine 7 (running) created at:
main.main()
/path/to/your/code/main.go:28 +0x9b
Goroutine 6 (running) created at:
main.main()
/path/to/your/code/main.go:28 +0x9b
==================这个报告会告诉你数据竞争发生的位置、涉及的 goroutine 以及相关的代码行数，帮助你快速定位和修复问题。
除了 Mutex 和 RWMutex，还有哪些并发控制工具？
除了
Mutex和
RWMutex，
sync包还提供了其他一些并发控制工具，例如：
-
sync.WaitGroup
： 用于等待一组 goroutine 完成。 -
sync.Once
： 用于确保某个函数只执行一次。 -
sync.Cond
： 用于实现基于条件的等待和通知机制。 -
atomic
包： 提供原子操作，用于对基本数据类型进行原子读写。
选择合适的并发控制工具取决于你的具体需求。例如，如果你需要等待一组 goroutine 完成，可以使用
sync.WaitGroup；如果你需要确保某个函数只执行一次，可以使用
sync.Once；如果你需要实现基于条件的等待和通知机制，可以使用
sync.Cond；如果你只需要对基本数据类型进行原子读写，可以使用
atomic包。
理解并熟练运用这些并发控制工具，可以帮助你编写出高效、可靠的并发程序。
