Golang控制协程执行顺序的三种实用方法

var count uint32
func sequence(i uint32, fn func()) {
	for {
		// 使用原子操作读取当前计数
		if n := atomic.LoadUint32(&count); n == i {
			fn()
			// 执行完成后，原子递增计数
			atomic.AddUint32(&count, 1)
			break // 当前任务完成，退出循环
		}
		time.Sleep(time.Nanosecond) // 避免 CPU 空转
	}
}

func main() {
	var times uint32 = 5
	for i := uint32(0); i < times; i++ {
		go func(i uint32) {
			fn := func() {
				fmt.Printf("this i is %v\n", i)
			}
			sequence(i, fn)
		}(i)
	}
	// 让主协程等待最后一个任务完成
	sequence(times, func() {})
}

func main() {
	c1 := make(chan struct{})
	c2 := make(chan struct{})
	c3 := make(chan struct{})

	go func() {
		// 协程一：直接执行，完成后关闭 c1
		fmt.Println("this value is 0")
		close(c1)
	}()

	go func() {
		// 协程二：等待 c1 关闭后执行，完成后关闭 c2
		<-c1
		fmt.Println("this value is 1")
		close(c2)
	}()

	go func() {
		// 协程三：等待 c2 关闭后执行
		<-c2
		fmt.Println("this value is 2")
		close(c3)
	}()

	// 主协程等待 c3 关闭，确保所有工作完成
	<-c3
}

func main() {
	times := 5
	// 创建 Mutex 数组，多一个用于主协程等待
	var cc = make([]*sync.Mutex, times+1)
	
	// 初始化：全部加锁
	for i := 0; i < len(cc); i++ {
		m := &sync.Mutex{}
		m.Lock()
		cc[i] = m
	}

	for i := 0; i < times; i++ {
		go func(index int) {
			// 等待前一个锁被释放
			cc[index].Lock()
			fmt.Printf("this value is %d \n", index)
			// 执行完成后，解锁自身位置并解锁下一位
			cc[index].Unlock()
			cc[index+1].Unlock()
		}(i)
	}

	// 解锁入口锁 (index 0)，启动链条
	cc[0].Unlock()
	
	// 主协程等待最后一个锁被释放
	cc[times].Lock()
	cc[times].Unlock()
}