Goroutine交替执行的相关问题与方法

多个Goroutine交替执行输出

文章目录

多个Goroutine交替执行输出
- 两个协程交替打印1-100的奇偶数
- - 使用channel作为信号传递实现
  - 使用runtime让协程竞争CPU
  - 使用sync的锁竞争实现
- N个线程交替打印0-100
- - 没有严格的交替顺序的时候
  - 有严格交替顺序的时候
- channel实现线程池
- 参考资料

Go语言的协程goroutine在高并发方面具有优势，最简单的可以写一个简单的生产者消费者模型。

func mode1() {rand.Seed(time.Now().UnixNano())wgreceivers := sync.WaitGroup{}wgreceivers.Add(NumReceiver)datach := make(chan int)Max := 100000NumReceiver := 10// sendergo func() {for {if value := rand.Intn(Max); value == 0 {close(datach)return} else {datach <- value}}}()// receiverfor i := 0; i < NumReceiver; i++ {go func() {defer wgreceivers.Done()for value := range datach {fmt.Println(value)}}()}wgreceivers.Wait()
}

还有经典的两个线程交替输出的问题，例如：

两个线程交替打印 0~100 的奇偶数

用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D…26Z

通过 N 个线程顺序循环打印从 0 至 100

其实这类就是线程通信相关的问题。Go语言的多线程、并发相关的知识，给我的感觉就是就是用起来容易，控制起来很难，存在很多似是而非的过程。如果想要掌握Go的并发，除了多加练习之外，还需要查看一些优秀的实践（比如channel的优雅关闭、goroutine线程池的实现等等——文末会有相关参考的链接）。
下面会从两个线程交替打印奇偶数开始讲起，会使用channel实现，使用sync的Lock实现，还有使用runtime的Gosched控制CPU实现。进一步拓展到N个线程打印的。

两个协程交替打印1-100的奇偶数

使用channel作为信号传递实现

刚学习goroutine的时候可能会这样写：

func withChannel(num int) {ch := make(chan int)wg := sync.WaitGroup{}wg.Add(1)// sendergo func() {for i := 1; i <= num; {fmt.Println("sender:", i)i++ch <- ii++//time.Sleep(2 * time.Millisecond)//可以人为制造停顿，努力让结果适配  :)  }close(ch)}()// receivergo func() {defer wg.Done()for i := range ch {fmt.Println("receiver:", i)}}()wg.Wait()fmt.Println("stop")
}// output:
// sender: 1
// sender: 3
// receiver: 2
// receiver: 4
// ...

上面的函数利用channel承载值的传递（并没有作为信号传递）。修改方法可以将channel变为信号传递，控制协程输出的时机：

func withChannel2(num int) {ch1, ch2 := make(chan struct{}), make(chan struct{})wg := sync.WaitGroup{}wg.Add(2)fmt.Println("start print:")go func() {defer wg.Done()for i := 1; i <= num; i += 2 {<-ch1fmt.Println("one: ", i)ch2 <- struct{}{}}<-ch1// 如果这里没有这一步，会直接死锁 }()go func() {defer wg.Done()// for i := 2; i < num; i += 2 {  // 如果在这里没有= ，会直接死锁for i := 2; i <= num; i += 2 {<-ch2fmt.Println("two: ", i)ch1 <- struct{}{}}}()ch1 <- struct{}{} // 启动的信号wg.Wait()fmt.Println("stop the work!")
}

使用runtime让协程竞争CPU

直接使用runtime的Gosched让出CPU，达到线程阻塞。

func withCPU() {//设置可同时使用的CPU核数为1var wg sync.WaitGroup// 定义使用核心的数量的数量runtime.GOMAXPROCS(1)wg.Add(2)go func() {defer wg.Done()for i := 1; i < 101; i++ {//奇数if i%2 == 1 {fmt.Println("线程1打印:", i)}//让出cpuruntime.Gosched()}}()go func() {defer wg.Done()for i := 1; i < 101; i++ {// 偶数if i%2 == 0 {fmt.Println("线程2打印:", i)}// 让出cpuruntime.Gosched()}}()wg.Wait()
}

使用sync的锁竞争实现

这个部分实现的比较冗杂，因为要显式让线程睡眠，实现交替的效果，使用了sync包的Cond控制条件，signal唤醒线程，这里就存在资源竞争。比较冗余。如果有更好的办法，欢迎和我交流