Go语言中，常用的同步机制

在 Go 语言中，保证多线程（或者更准确地说，多协程）有序执行，主要依赖于协程间的同步机制。Go 提供了几种工具来帮助开发者控制协程（goroutine）的执行顺序，确保数据的一致性和操作的原子性。下面是一些常用的同步机制：

1. 使用通道（Channel）

通道是 Go 中协程间通信的主要方式，通过通道可以安全地在协程之间传递数据，从而控制执行顺序。

示例：使用无缓冲通道实现同步
无缓冲通道保证发送操作在接收准备好之前是阻塞的，这可以用来控制协程的执行顺序。

package main

import (
    "fmt"
    "sync"
)

func main() {
    ch := make(chan bool)
    go worker(ch)
    ch <- true  // 主协程通过发送信号控制worker的开始执行
    fmt.Println("sent true to worker")
}

func worker(ch chan bool) {
    <-ch  // 等待主协程的信号
    fmt.Println("Received true, start working")
}

2. 使用 sync 包

sync 包提供了多种同步工具，如互斥锁（Mutex）、读写锁（RWMutex）、WaitGroup 等。

示例：使用 WaitGroup 等待多个协程完成
WaitGroup 是用来等待一组协程执行完成。每个协程在开始时调用 WaitGroup.Add(1)，完成时调用 WaitGroup.Done()，而 WaitGroup.Wait() 会阻塞直到所有协程报告完成。

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    
    go func() {
        defer wg.Done()
        time.Sleep(2 * time.Second)
        fmt.Println("Task 1 completed")
    }()
    
    go func() {
        defer wg.Done()
        fmt.Println("Task 2 completed")
    }()
    
    wg.Wait()
    fmt.Println("All tasks completed")
}

3. 使用互斥锁（Mutex）

互斥锁用于保护共享资源，在多个协程需要访问同一资源时，使用 Mutex 来保证同一时刻只有一个协程可以访问该资源。

package main

import (
    "fmt"
    "sync"
)

var (
    counter int
    lock    sync.Mutex
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go updateCounter(&wg)
    go updateCounter(&wg)

    wg.Wait()
    fmt.Printf("Final Counter: %d\n", counter)
}

func updateCounter(wg *sync.WaitGroup) {
    defer wg.Done()
    lock.Lock()
    defer lock.Unlock()
    for i := 0; i < 1000; i++ {
        counter++
    }
}

总结

保证多协程有序执行的关键是正确使用 Go 的同步机制。选择哪种机制取决于具体的应用场景：

• 使用通道可以实现优雅的协程间通信和同步。
• 使用 sync.WaitGroup 适合管理多个协程的完成状态。
• 使用互斥锁（Mutex）来保护共享资源，防止竞态条件。

在设计并发程序时，合理地选择和使用这些工具是非常关键的。