golang实现并发控制的方法和技巧

发表于Go语言交流版块教程

在Go语言中，实现并发控制是编写高效并行程序的关键。Go提供了多种机制来帮助开发者管理并发，包括goroutine、channel、sync包中的锁和等待组等。以下是一些实现并发控制的方法和技巧。1.

在Go语言中，实现并发控制是编写高效并行程序的关键。Go提供了多种机制来帮助开发者管理并发，包括goroutine、channel、sync包中的锁和等待组等。以下是一些实现并发控制的方法和技巧。

1. 使用goroutine进行并发

Go的并发是通过轻量级的goroutine来实现的。你可以通过在函数调用前加上go关键字来启动一个新的goroutine。

func doSomeWork() {
    // 做一些工作
}

func main() {
    go doSomeWork() // 并发执行
    doSomeOtherWork() // 顺序执行
}

2. 使用channel进行通信

Channel是goroutine之间通信的管道。你可以通过channel来同步goroutine的执行和传递数据。

func worker(id int, ch <-chan int) {
    for n := range ch {
        fmt.Printf("Worker %d received %d\n", id, n)
    }
}

func main() {
    ch := make(chan int, 5)
    go worker(1, ch)
    go worker(2, ch)

    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch) // 关闭channel
}

3. 使用sync包中的锁

Mutex（互斥锁）：确保同一时间只有一个goroutine可以访问共享资源。

var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

RWMutex（读写锁）：允许多个goroutine同时读取，但写入时需要独占访问。

var rwmu sync.RWMutex
var data interface{}

func readData() {
    rwmu.RLock()
    defer rwmu.RUnlock()
    // 读取data
}

func writeData(d interface{}) {
    rwmu.Lock()
    defer rwmu.Unlock()
    data = d
    // 写入data
}

4. 使用WaitGroup等待goroutine完成

sync.WaitGroup是一个计数器，可以用来等待一组goroutine完成。

var wg sync.WaitGroup

func doWork() {
    defer wg.Done() // 确保在goroutine完成时调用Done
    // 做一些工作
}

func main() {
    wg.Add(1)
    go doWork()
    wg.Wait() // 等待所有goroutine完成
}

5. 使用context控制goroutine的生命周期

context包提供了一种机制来传播请求的截止时间、取消信号和请求范围的值。

func worker(ctx context.Context) {
    select {
    case <-time.After(10 * time.Second):
        fmt.Println("worker done")
    case <-ctx.Done():
        fmt.Println("context cancelled")
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    go worker(ctx)
    time.Sleep(5 * time.Second)
    cancel() // 取消上下文，通知worker退出
}

6. 避免死锁

使用sync.Mutex时，确保以一致的顺序获取锁，以避免死锁。可以使用sync.Mutex的Lock()方法返回的错误来检测死锁。

var mu sync.Mutex

func accessResource() {
    if err := mu.Lock(); err != nil {
        log.Fatalf("Failed to lock: %v", err)
    }
    defer mu.Unlock()

    // 访问资源
}

7. 使用原子操作

对于简单的操作，可以使用sync/atomic包提供的原子操作来避免锁的使用。

var counter int64

func increment() {
    atomic.AddInt64(&counter, 1)
}

8. 限制并发数

使用semaphore（信号量）来限制同时运行的goroutine数量。

var sem = make(chan struct{}, 10) // 限制并发数为10

func doWork() {
    sem <- struct{}{} // 获取信号量
    defer func() {
        <-sem // 释放信号量
    }()
    // 做一些工作
}

func main() {
    for i := 0; i < 20; i++ {
        go doWork()
    }
}