两个协程交替打印1到20

题目来源：字节跳动

频次：2

答案：小小

1. 使用channel

package main

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


func main() {
    wg := &sync.WaitGroup{}
    ch1 := make(chan int)
    ch2 := make(chan int)

    wg.Add(2)
    go say(wg, ch2, ch1)
    go say1(wg, ch1, ch2)
    wg.Wait()
    time.Sleep(1 * time.Second)
}

func say(wg *sync.WaitGroup, ch2 chan int, ch1 chan int) {
    defer wg.Done()
    for i := 1; i <= 10; i++ {
        ch2 <- 2*i - 1
        fmt.Println(<-ch1)
    }
}

func say1(wg *sync.WaitGroup, ch1 chan int, ch2 chan int) {
    defer wg.Done()
    for i := 1; i <= 10; i++ {
        fmt.Println(<-ch2)
        ch1 <- 2 * i
    }
}

2.使用锁

//使用锁
// 一个协程对该变量进行操作时进行加锁，另一个协程等待。
// 释放锁后再进行操作，每次操作进行加1即可

package main
import (
    "fmt"
    "sync"
    "time"
)
type Alternate struct {
    count int
    mu sync.Mutex
}
func main(){
    tong:=Alternate{count: 0}
    go tong.printOld()
    time.Sleep(time.Millisecond*20)
    go tong.printEvent()
    time.Sleep(time.Second*3)
}

// 两个协程，一个获取锁一个等待不断交换
// 打印第一个数
func (tong *Alternate)printOld(){
    for tong.count<20{
        tong.mu.Lock()
        tong.count += 1
        fmt.Println(tong.count)
        tong.mu.Unlock()
    }
    return

}
// 第二个数 = 第一个数 + 1
func (tong *Alternate)printEvent(){
    for tong.count<20{
        tong.mu.Lock()
        tong.count += 1
        fmt.Println(tong.count)
        tong.mu.Unlock()
    }
    return
}