GO语言面试系列:（六）子goroutine与主线程的同步及面试

如何实现子goroutine与主线程的同步

1、第一种方式：time.sleep():

package main

import (
        "fmt"
        "time"
)

func printCount() {
        for i := 0; i < 10; i++ {
            fmt.Println(i)
        }
}

func main() {
        go printCount()
        time.Sleep(time.Millisecond * 100)
}

这种方式没法正确预估goroutine执行的时间，很死板，不推荐使用。

2、第二种方式：使用channel机制，每个goroutine传一个channel进去然后往里写数据，在再主线程中读取这些channel，直到全部读到数据了子goroutine也就全部运行完了，那么主goroutine也就可以结束了。这种模式是子线程去通知主线程结束。

package main

import (
        "fmt"
)

func printCount(rs chan int) {
        defer close(rs)
        for i := 0; i < 10; i++ {
                rs <- i
        }
}

func main() {
        rs := make(chan int, 10)
        go printCount(rs)

        for v := range rs {
                fmt.Println(v)
        }
}

3、第三种方式：使用context中cancel函数，这种模式是主线程去通知子线程结束。

package main

import (
        "context"
        "fmt"
)

func printCount(ctx context.Context) chan int {
        dst := make(chan int)
        n := 0
        go func() {
                for {
                        select {
                                case <-ctx.Done():
                                        return
                                case dst <- n:
                                        n++
                        }
                }
        }()
        return dst
}

func main() {
        ctx, cancel := context.WithCancel(context.Background())
        defer cancel()

        intChan := printCount(ctx)
        for n := range intChan {
                if n == 9 {
                        break
                }
                fmt.Println(n)
        }
}

4、第四种方式：sync.WaitGroup模式，Add方法设置等待子goroutine的数量，使用Done方法设置等待子goroutine的数量减1，当等待的数量等于0时，Wait函数返回。

package main

import (
        "fmt"
        "sync"
)

func printCount(wgp *sync.WaitGroup) {
        defer wgp.Done()
        for i := 0; i < 10; i++ {
                fmt.Println(i)
        }
}

func main() {
        wgp := &sync.WaitGroup{}
        wgp.Add(1)
        go printCount(wgp)
        wgp.Wait()
}

案例一:

1. 问题描述 使用两个 goroutine 交替打印序列，一个 goroutinue 打印数字， 另外一个goroutine打印字母， 最终效果如下 12AB34CD56EF78GH910IJ 。
2. 解题思路 问题很简单，使用 channel来控制打印的进度。使用两个channel ，来分别控制数字和字母的打印序列， 数字打印完成后通过 channel 通知字母打印, 字母打印完成后通知数字打印，然后周而复始的工作。
3. 代码实现

package main

import (
        "fmt"
        "runtime"
)

func main() {
        runtime.GOMAXPROCS(runtime.NumCPU())
        chan_n := make(chan bool)
        chan_c := make(chan bool, 1)
        done := make(chan struct{})

        go func() {
                for i := 1; i < 11; i += 2 {
                        <-chan_c
                        fmt.Printf("%d", i)
                        fmt.Printf("%d", i+1)
                        chan_n <- true
                }
        }()

        go func() {
                char_seq := [...]string{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J"}
                for i := 0; i < 10; i += 2 {
                        <-chan_n
                        fmt.Printf("%s", char_seq[i])
                        fmt.Printf("%s", char_seq[i+1])
                        chan_c <- true
                }
                done <- struct{}{}
        }()

        chan_c <- true
        <-done
}

代码执行结果:

12AB34CD56EF78GH910IJ

声明：文章来源多来自互联网，如果您感觉文章侵犯您的个人著作权，请联系我们，会在第一时间删除。

来源：https://studygolang.com/articles/10786

关注小编微信：grey0805，了解更多哦！