117笔记问答在Go语言中，有多种方法可以实现并发编程的同步。以下是一些常用的同步机制：
- Mutex（互斥锁）：Mutex是最基本的同步原语，用于保护共享资源免受多个goroutine同时访问的影响。Go标准库中的
sync包提供了Mutex结构体和相关的方法，如Lock()、Unlock()等。使用Mutex时，需要注意避免死锁问题。
import (
"sync"
)
var mu sync.Mutex
var counter int
func increment() {
mu.Lock()
counter++
mu.Unlock()
}
- RWMutex（读写锁）：RWMutex是一种更高级的同步原语，允许多个goroutine同时读取共享资源，但在写入时会阻塞其他读写操作。这在读操作远多于写操作的场景下非常有用。Go标准库中的
sync包提供了RWMutex结构体和相关的方法，如RLock()、RUnlock()、Lock()、Unlock()等。
import (
"sync"
)
var rwMu sync.RWMutex
var sharedData map[string]string
func readData(key string) {
rwMu.RLock()
defer rwMu.RUnlock()
value, ok := sharedData[key]
if !ok {
fmt.Println("Key not found")
} else {
fmt.Println("Value:", value)
}
}
func writeData(key, value string) {
rwMu.Lock()
defer rwMu.Unlock()
sharedData[key] = value
}
- WaitGroup：WaitGroup用于等待一组goroutine完成执行。它提供了一种简单的方式来同步多个并发任务。Go标准库中的
sync包提供了WaitGroup结构体和相关的方法，如Add()、Done()、Wait()等。
import (
"fmt"
"sync"
"time"
)
func worker(wg *sync.WaitGroup, id int) {
defer wg.Done()
fmt.Printf("Worker %d starting\n", id)
time.Sleep(time.Second)
fmt.Printf("Worker %d done\n", id)
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 5; i++ {
wg.Add(1)
go worker(&wg, i)
}
wg.Wait()
fmt.Println("All workers done")
}
- Channel：Channel是Go语言中的一种内置数据结构，可以用于在不同goroutine之间传递数据和实现同步。通过使用带缓冲的Channel，可以在一定程度上实现生产者-消费者模式。Go标准库中的
fmt包提供了make()函数用于创建Channel。
import (
"fmt"
"time"
)
func producer(ch chan<- int) {
for i := 0; i < 5; i++ {
ch <- i
time.Sleep(time.Second)
}
close(ch)
}
func consumer(ch <-chan int) {
for num := range ch {
fmt.Println("Received:", num)
time.Sleep(2 * time.Second)
}
}
func main() {
ch := make(chan int, 5)
go producer(ch)
consumer(ch)
}
这些同步机制可以根据具体场景和需求进行组合使用，以实现更复杂的并发编程模式。