Golang中除了加Mutex锁以外还有哪些方式可以安全读写共享变量？
参考回答
除了使用 sync.Mutex 来保护共享变量，Golang 还提供其他多种方式实现并发环境下的安全读写共享变量，包括以下常用方法：
sync.RWMutex：读写锁，允许多个读操作同时进行，但写操作是独占的。sync/atomic：原子操作，用于对整数、布尔值等基础类型的共享变量进行高效的读写。- Channel：利用通道实现消息传递式的同步操作，避免直接访问共享变量。
sync.Map：线程安全的 map，内置并发支持，适用于共享键值对的读写。
详细讲解与拓展
1. 使用 sync.RWMutex
sync.RWMutex 是一种读写锁，与 sync.Mutex 的区别在于它允许多个 Goroutine 并发读取，但写操作是互斥的。适用于读多写少的场景。
示例：
package main
import (
"fmt"
"sync"
)
var (
data = 0
rwMux sync.RWMutex
wg sync.WaitGroup
)
func read() {
defer wg.Done()
rwMux.RLock() // 加读锁
fmt.Println("Read:", data)
rwMux.RUnlock() // 解读锁
}
func write(value int) {
defer wg.Done()
rwMux.Lock() // 加写锁
data = value
fmt.Println("Write:", value)
rwMux.Unlock() // 解写锁
}
func main() {
for i := 0; i < 5; i++ {
wg.Add(1)
go read()
wg.Add(1)
go write(i)
}
wg.Wait()
}
特点：
- 适合高并发读、多 Goroutine 场景。
- 写锁会阻塞读锁，写优先于读。
2. 使用 sync/atomic
sync/atomic 提供了底层的原子操作，避免了锁的开销。常用于对基础类型变量的并发读写操作，如 int32、int64 等。
示例：
package main
import (
"fmt"
"sync/atomic"
)
var counter int64
func increment() {
for i := 0; i < 1000; i++ {
atomic.AddInt64(&counter, 1) // 原子加
}
}
func main() {
go increment()
go increment()
fmt.Println("Final Counter:", atomic.LoadInt64(&counter)) // 原子加载
}
特点：
- 高效，适合操作简单的共享变量。
- 只支持基础类型（
int、uint、bool等），不支持复杂数据结构。
3. 使用 Channel
通过 Channel 传递消息来协调多个 Goroutine 的读写，避免共享变量直接暴露在多个 Goroutine 中。利用 Channel 的同步特性，保证共享变量的安全访问。
示例：使用 Channel 实现安全累加器
package main
import (
"fmt"
)
func main() {
ch := make(chan int)
go func() {
total := 0
for val := range ch {
total += val
fmt.Println("Total:", total)
}
}()
// 向通道发送数据
for i := 1; i <= 5; i++ {
ch <- i
}
close(ch) // 关闭通道
}
特点：
- 利用消息传递代替直接共享数据，避免竞争条件。
- 更符合 Go 提倡的 “不要通过共享内存来通信，而通过通信来共享内存” 的理念。
4. 使用 sync.Map
sync.Map 是 Go 标准库提供的线程安全 map，适用于并发访问共享键值对数据的场景。
示例：
package main
import (
"fmt"
"sync"
)
func main() {
var sm sync.Map
// 写入数据
sm.Store("key1", "value1")
sm.Store("key2", "value2")
// 读取数据
if val, ok := sm.Load("key1"); ok {
fmt.Println("key1:", val)
}
// 删除数据
sm.Delete("key2")
// 遍历数据
sm.Range(func(key, value interface{}) bool {
fmt.Printf("Key: %s, Value: %s\n", key, value)
return true
})
}
特点：
- 内置并发支持，无需加锁。
- 性能较高，但不适合频繁读写的场景。
5. 使用 sync.Cond（扩展）
sync.Cond 是一种条件变量，配合 sync.Mutex 使用，用于实现更复杂的同步操作。例如，可以用它控制多个 Goroutine 按照特定的条件执行。
示例：
package main
import (
"fmt"
"sync"
)
func main() {
mux := sync.Mutex{}
cond := sync.NewCond(&mux)
go func() {
mux.Lock()
fmt.Println("Goroutine 1 waiting...")
cond.Wait() // 等待条件满足
fmt.Println("Goroutine 1 proceeding")
mux.Unlock()
}()
go func() {
mux.Lock()
fmt.Println("Goroutine 2 waiting...")
cond.Wait() // 等待条件满足
fmt.Println("Goroutine 2 proceeding")
mux.Unlock()
}()
// 通知所有 Goroutine 继续
mux.Lock()
fmt.Println("Signaling all goroutines")
cond.Broadcast() // 广播通知
mux.Unlock()
}
特点：
- 用于复杂的同步场景，例如生产者/消费者模型。
- 需要小心处理条件变量和锁的配合。
总结
除了使用 sync.Mutex，Golang 提供了多种并发安全的共享变量读写方式：
1. sync.RWMutex：适合读多写少场景。
2. sync/atomic：高效的基础类型原子操作。
3. Channel：通过消息传递避免直接操作共享变量。
4. sync.Map：线程安全的 map，适用于共享键值对的场景。
5. sync.Cond（扩展）：用于复杂的条件同步。
选择合适的方式取决于场景需求和性能权衡，例如：
– 对于简单计数器，使用 atomic。
– 对于键值对存储，使用 sync.Map。
– 对于生产者/消费者模型，优先选择 Channel。