sync.Once
专门用于确保某些初始化代码只被执行一次，不论该代码由多少个 goroutine 调用.
package main
import (
"fmt"
"sync"
"time"
)
func main() {
var once sync.Once
for i := 0; i < 10; i++ {
go func() {
// sync.Once 提供了一个方法 Do，这个方法接受一个函数作为参数，并确保该函数只会被执行一次
once.Do(func() {
fmt.Println("once")
})
}()
}
time.Sleep(1 * time.Second)
}
常用于单例模式，如
package main
import (
"fmt"
"sync"
)
type Singleton struct {
// Fields for the singleton
}
var instance *Singleton
var once sync.Once
func GetInstance() *Singleton {
once.Do(func() {
instance = &Singleton{}
fmt.Println("Singleton instance created")
})
return instance
}
sync.WaitGroup
WaitGroup 用于等待一组 goroutine 完成。可以增加计数器，并在 goroutine 完成时减少计数器
package main
import (
"fmt"
"sync"
)
func main() {
var once sync.Once
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
defer wg.Done()
once.Do(func() {
fmt.Println("once")
})
}()
}
wg.Wait()
}
sync.Mutex
Mutex 是一个互斥锁，用于保护临界区，确保同一时间只有一个 goroutine 能够访问被保护的代码.
package main
import (
"fmt"
"sync"
)
var count int
var mutex sync.Mutex
// 通过Mutex解决线程安全问题
func Increase() {
mutex.Lock()
count++
mutex.Unlock()
}
func main() {
var wg sync.WaitGroup
for i := 0; i < 500; i++ {
wg.Add(1)
go func() {
defer wg.Done()
Increase()
}()
}
wg.Wait()
fmt.Println(count)
}
sync.RWMutex
RWMutex 是一种读写互斥锁，允许多个读操作同时进行，但写操作会独占锁。
package main
import (
"fmt"
"sync"
)
var counter int
var rwMutex sync.RWMutex
func read() int {
rwMutex.RLock()
defer rwMutex.RUnlock()
return counter
}
func write(val int) {
rwMutex.Lock()
counter = val
rwMutex.Unlock()
}
func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
write(i)
fmt.Println("Read value:", read())
}(i)
}
wg.Wait()
}
