在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)
}

這些同步機制可以根據具體場景和需求進行組合使用，以實現更復雜的并發編程模式。