Golang循环屏障(CyclicBarrier)并发编程指南

循环屏障(CyclicBarrier)是一种常见的并发同步机制，它允许多个goroutine在某个屏障点等待，直到所有goroutine都到达该点后才能继续执行。下面我将详细介绍如何在Go中实现和使用循环屏障。

1. 基本概念

循环屏障类似于一个集合点，当一组goroutine都到达屏障点时，它们才能继续执行。与一次性屏障不同，循环屏障可以重复使用。

2. 标准库实现

Go标准库中没有直接提供CyclicBarrier，但我们可以使用sync包中的原语来实现。下面是一个简单的实现：

package cyclicbarrier

import (
	"sync"
)

type CyclicBarrier struct {
	parties      int
	count       int
	cond        *sync.Cond
	isBroken    bool
	barrierFunc func()
}

func New(parties int, barrierFunc func()) *CyclicBarrier {
	if parties <= 0 {
		panic("parties must be positive number")
	}
	return &CyclicBarrier{
		parties:      parties,
		count:        parties,
		cond:        sync.NewCond(&sync.Mutex{}),
		barrierFunc: barrierFunc,
	}
}

func (cb *CyclicBarrier) Await() {
	cb.cond.L.Lock()
	defer cb.cond.L.Unlock()

	if cb.isBroken {
		panic("barrier is broken")
	}

	cb.count--
	if cb.count > 0 {
		// 等待其他goroutine到达
		cb.cond.Wait()
	} else {
		// 最后一个到达的goroutine执行屏障函数并唤醒其他goroutine
		cb.count = cb.parties // 重置计数器
		if cb.barrierFunc != nil {
			cb.barrierFunc()
		}
		cb.cond.Broadcast()
	}
}

func (cb *CyclicBarrier) Reset() {
	cb.cond.L.Lock()
	defer cb.cond.L.Unlock()
	
	cb.count = cb.parties
	cb.isBroken = false
	cb.cond.Broadcast()
}

3. 使用示例

下面是一个使用循环屏障的完整示例：

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

func main() {
	const parties = 3
	
	// 创建循环屏障，设置参与方数量和屏障动作
	barrier := New(parties, func() {
		fmt.Println("\nAll goroutines reached the barrier\n")
	})

	var wg sync.WaitGroup
	wg.Add(parties)

	for i := 0; i < parties; i++ {
		go func(id int) {
			defer wg.Done()
			
			for j := 0; j < 3; j++ { // 循环3次
				// 模拟工作
				time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
				fmt.Printf("Goroutine %d completed phase %d\n", id, j)
				
				// 等待其他goroutine
				barrier.Await()
			}
		}(i)
	}

	wg.Wait()
	fmt.Println("All goroutines finished")
}

4. 第三方库

如果你不想自己实现，可以使用第三方库如github.com/marusama/cyclicbarrier：

package main

import (
	"fmt"
	"time"

	"github.com/marusama/cyclicbarrier"
)

func main() {
	// 创建循环屏障
	b := cyclicbarrier.New(3)

	// 启动3个goroutine
	for i := 0; i < 3; i++ {
		go func(id int) {
			for j := 0; j < 3; j++ {
				fmt.Printf("Goroutine %d is working on phase %d\n", id, j)
				time.Sleep(time.Duration(id*100) * time.Millisecond)
				// 等待其他goroutine
				err := b.Await()
				if err != nil {
					fmt.Println(err)
					return
				}
				fmt.Printf("Goroutine %d passed barrier %d\n", id, j)
			}
		}(i)
	}

	time.Sleep(5 * time.Second)
}

5. 使用场景

循环屏障特别适用于以下场景：

1. 并行计算中需要同步多个计算阶段
2. 多阶段测试，每个阶段需要所有测试用例都完成才能进入下一阶段
3. 模拟多玩家游戏中的回合制同步

6. 注意事项

1. 确保屏障的参与方数量设置正确
2. 处理可能的超时和中断情况
3. 避免死锁，确保所有goroutine最终都能到达屏障点
4. 考虑使用带超时的Await方法防止永久阻塞

通过合理使用循环屏障，可以有效地协调多个goroutine的执行流程，实现复杂的并发模式。