当前位置：首页 > news >正文

【Golang】Golang中有哪些方式可以进行安全读写共享变量

news 2025/5/6 12:54:46

文章目录

前言
一、介绍
- 1. sync.Mutex
- 2. sync.RWMutex
- 3. sync/atomic
- 4. channel
- 5. sync.Map
二、代码实现
- - 2.1 使用sync.Mutex
  - 2.2 使用sync.RWMutex
  - 2.3. 使用sync/atomic
  - 2.4使用channel
  - 2.4使用sync.Map
三、总结

前言

在并发编程中，安全地读写共享变量是一个非常重要的问题。Go语言（Golang）提供了多种机制来确保在多线程环境下对共享变量的安全访问。本文将介绍几种常见的方式，包括sync.Mutex、sync.RWMutex、sync/atomic、channel和sync.Map，并通过代码示例展示如何使用这些机制。

一、介绍

1. sync.Mutex

sync.Mutex是Go语言中最基本的互斥锁，用于保护共享资源的读写。它通过锁定和解锁来确保同一时间只有一个goroutine可以访问共享变量。

2. sync.RWMutex

sync.RWMutex是一种读写锁，允许多个读操作同时进行，但写操作是互斥的。它比sync.Mutex更适合读多写少的场景。

3. sync/atomic

sync/atomic包提供了底层的原子操作，可以对整数和指针类型进行原子读写操作，适用于简单的计数器或标志位等场景。

4. channel

channel是Go语言中的一种通信机制，可以用来在多个goroutine之间安全地传递数据。通过channel可以实现对共享变量的安全读写。

5. sync.Map

sync.Map是Go 1.9引入的一种并发安全的map，适用于需要频繁读写的场景。

二、代码实现

2.1 使用sync.Mutex

package mainimport ("fmt""sync"
)var (mutex     sync.MutexsharedVar int
)func read() {mutex.Lock()defer mutex.Unlock()fmt.Println("Read:", sharedVar)
}func write(value int) {mutex.Lock()defer mutex.Unlock()sharedVar = valuefmt.Println("Write:", sharedVar)
}func main() {var wg sync.WaitGroupwg.Add(2)go func() {defer wg.Done()read()}()go func() {defer wg.Done()write(42)}()wg.Wait()
}

2.2 使用sync.RWMutex

package mainimport ("fmt""sync"
)var (rwMutex   sync.RWMutexsharedVar int
)func read() {rwMutex.RLock()defer rwMutex.RUnlock()fmt.Println("Read:", sharedVar)
}func write(value int) {rwMutex.Lock()defer rwMutex.Unlock()sharedVar = valuefmt.Println("Write:", sharedVar)
}func main() {var wg sync.WaitGroupwg.Add(2)go func() {defer wg.Done()read()}()go func() {defer wg.Done()write(42)}()wg.Wait()
}

2.3. 使用sync/atomic

package mainimport ("fmt""sync""sync/atomic"
)var sharedVar int64func read() {value := atomic.LoadInt64(&sharedVar)fmt.Println("Read:", value)
}func write(value int64) {atomic.StoreInt64(&sharedVar, value)fmt.Println("Write:", value)
}func main() {var wg sync.WaitGroupwg.Add(2)go func() {defer wg.Done()read()}()go func() {defer wg.Done()write(42)}()wg.Wait()
}

2.4使用channel

package mainimport ("fmt"
)func main() {ch := make(chan int)done := make(chan bool)// Writer goroutinego func() {ch <- 42done <- true}()// Reader goroutinego func() {value := <-chfmt.Println("Read:", value)done <- true}()// Wait for both goroutines to finish<-done<-done
}

2.4使用sync.Map

package mainimport ("fmt""sync"
)var sharedMap sync.Mapfunc read(key string) {if value, ok := sharedMap.Load(key); ok {fmt.Println("Read:", value)} else {fmt.Println("Key not found")}
}func write(key string, value interface{}) {sharedMap.Store(key, value)fmt.Println("Write:", value)
}func main() {var wg sync.WaitGroupwg.Add(2)go func() {defer wg.Done()write("key1", 42)}()go func() {defer wg.Done()read("key1")}()wg.Wait()
}