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

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() {
		//協程一 不受限制 直接執行 執行結束后關閉通道一
		fmt.Println("this value is 0")
		close(c1)
	}()
	go func() {
		//協程二 需要從通道一中接收值 ，或者通道關閉時，獲取到接收失敗的結果，否則一直阻塞
		//執行結束后關閉通道二
		<-c1
		fmt.Println("this value is 1")
		close(c2)
	}()
	go func() {
		//協程三 需要從通道二中接收值 ，或者通道關閉時，獲取到接收失敗的結果，否則一直阻塞
		//執行結束后關閉通道三
		<-c2
		fmt.Println("this value is 2")
		close(c3)
	}()
	//主協程 需要從通道三中接收值 ，或者通道關閉時，獲取到接收失敗的結果，否則一直阻塞
	<-c3
}

func main() {
	times := 5
	//創建一個互斥鎖數組 多一個給主協程用
	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) {
			//子協程嘗試為數組中對應 index 位置的鎖加鎖，獲取不到鎖就等待
			//因為初始化的這些互斥鎖默認就已經被鎖住了，所以這里創建的子協程都會被阻塞
			//一旦獲取到鎖，就執行邏輯，最后將當前index的鎖和index+1的鎖釋放，這樣正在等待 index +1 位置的鎖的子協程就可以繼續執行了
			cc[index].Lock()
			fmt.Printf("this value is %d \n", index)
			cc[index].Unlock()
			cc[index+1].Unlock()
		}(i)
	}
	//將index 為 0 位置的鎖解鎖，讓第一個子協程可以繼續執行
	cc[0].Unlock()
	//為 index 為 times 的鎖加鎖，只有當最后一個子協程執行完畢后，這個鎖才會解鎖，主協程才能繼續向下走
	cc[times].Lock()
	cc[times].Unlock()
}