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,了解更多哦!

    原文作者:Chole121
    原文地址: https://www.jianshu.com/p/a7a7035b9f16
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞