Go语言并发编程怎样实现同步

在Go语言中，有多种方法可以实现并发编程的同步。以下是一些常用的同步机制：

1. 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()
}

2. 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
}

3. 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")
}

4. 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)
}

这些同步机制可以根据具体场景和需求进行组合使用，以实现更复杂的并发编程模式。