用channel，mutex实现交叉输出

使用mutex实现

package main

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

var wg sync.WaitGroup
var mutex sync.Mutex
var odd = true

// 打印奇数
func test1() {
	defer wg.Done()
	for i := 1; i < 10; i += 2 {
		mutex.Lock()
		for !odd { //偶数打印就等待
			mutex.Unlock()
			time.Sleep(time.Millisecond)
			mutex.Lock()
		}
		fmt.Println(i)
		odd = false
		mutex.Unlock()
	}
}

// 打印偶数
func test2() {
	defer wg.Done()
	for i := 2; i <= 10; i += 2 {
		mutex.Lock()
		for odd { //奇数打印就等待
			mutex.Unlock()
			time.Sleep(time.Millisecond)
			mutex.Lock()
		}
		fmt.Println(i)
		odd = true
		mutex.Unlock()
	}
}

func main() {
	beginTime := time.Now()
	wg.Add(2)
	go test1()
	go test2()
	wg.Wait()
	endTime := time.Now()
	fmt.Println(endTime.Sub(beginTime))//获取运行总时长
}

运行总时长10.226ms左右

但是time.Sleep(time.Millisecond)会浪费cpu资源，执行时间长

使用 channel

package main

import (
	"fmt"
	"time"
)


// printOddNumbers 函数负责打印奇数
func printOddNumbers(startChan, nextChan chan struct{}) {
	for i := 1; i <= 9; i += 2 {
		<-startChan // 等待开始信号
		fmt.Println(i)
		nextChan <- struct{}{} // 发送结束信号给下一个协程
	}
}

// printEvenNumbers 函数负责打印偶数
func printEvenNumbers(startChan, nextChan chan struct{}) {
	for i := 2; i <= 10; i += 2 {
		<-startChan // 等待开始信号
		fmt.Println(i)
		nextChan <- struct{}{} // 发送结束信号给下一个协程
	}
}

func main() {
	oddChan := make(chan struct{})
	evenChan := make(chan struct{})

	// 启动两个协程，一个负责打印奇数，另一个负责打印偶数
	go printOddNumbers(oddChan, evenChan)
	go printEvenNumbers(evenChan, oddChan)

	// 发送初始信号给奇数协程
	oddChan <- struct{}{}

	// 主函数等待一段时间，确保所有数字都被打印
	time.Sleep(time.Second)

	// 关闭channel，通知所有协程停止
	close(oddChan)
	close(evenChan)
}