脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|shell|

服务器之家 - 脚本之家 - Golang - Golang协程常见面试题小结

Golang协程常见面试题小结

2023-02-28 15:22一个山里的少年 Golang

本文主要介绍了Golang协程常见面试题小结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

交替打印奇数和偶数

下面让我们一起来看看golang当中常见的算法面试题
使用两个goroutine交替打印1-100之间的奇数和偶数, 输出时按照从小到大输出.

方法一：使用无缓冲的channel进行协程间通信

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package main
 
import (
    "fmt"
    "sync"
)
 
// PrintOddAndEven1 /*
func PrintOddAndEven1() {
    //方法一,使用无缓冲的channel进行通信
    var wg = new(sync.WaitGroup) //注意这里需要是指针go语言当中都是值传递
    wg.Add(2)
    ch := make(chan struct{}) //无缓冲channel
    defer close(ch)
    maxVal := 100
    go func() {
        defer wg.Done()
        for i := 1; i <= maxVal; i++ {
            ch <- struct{}{}
            if i%2 == 1 { //奇数
                fmt.Printf("the odd is %d\n", i)
 
            }
        }
    }()
 
    go func() {
        defer wg.Done()
        for i := 1; i <= maxVal; i++ {
            <-ch          //从管道当中读取一个数据
            if i%2 == 0 { //偶数
                fmt.Printf("the even is %d\n", i)
 
            }
        }
    }()
    wg.Wait()
 
}
func main() {
    PrintOddAndEven1()
    fmt.Println("over")
}

下面博主来解释一下这个的原理 首先因为变量ch是一个无缓冲的channel, 所以只有读写同时就绪时才不会阻塞。所以两个goroutine会同时进入各自的 if 语句（此时 i 是相同的），但是此时只能有一个 if 是成立的，不管goroutine快，都会由于读channel或写channel导致阻塞，因此程序会交替打印1-100且有顺序。

方法二：使用有缓冲的channel

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
func PrintOddAndEven2() {
    var wg = new(sync.WaitGroup) //注意这里需要是指针go语言当中都是值传递
    wg.Add(2)
    oddChan := make(chan struct{}, 1)
    eveChan := make(chan struct{}, 1)
    defer close(oddChan)
    defer close(eveChan)
    oddChan <- struct{}{}
    maxVal := 20
    go func() { //奇数协程
        defer wg.Done()
        for i := 1; i <= maxVal; i += 2 {
            <-oddChan
            fmt.Printf("the odd print %d\n", i)
            eveChan <- struct{}{} //通知偶数协程
        }
    }()
 
    go func() {
        //偶数协程
        defer wg.Done()
        for i := 2; i <= maxVal; i += 2 {
            <-eveChan
            fmt.Printf("the even print %d\n", i)
            oddChan <- struct{}{} //通知奇数协程可以打印了
        }
    }()
    wg.Wait()
 
}
 
func main() {
    PrintOddAndEven2()
    fmt.Println("over")
}

第二个方法使用这个有缓冲的channel。有缓冲的channel当容量没有达到上限时写入不会阻塞在这里奇数协程的channel容量为1我们提前给他写入了一个数据因此当偶数和奇数协程都开始读取数据时，首先读取到数据的是奇数协程，奇数协程打印完之后在通知偶数协程打印，偶数协程打印完成之后在通知奇数协程重复下去就实现了交替打印的效果。

N个协程打印1到maxVal

题目描述非常的简单就是N个协程交替打印1到maxVal。比如N=3,maxVal是这个100效果应该是第一个协程打印1，第二个协程打印2，第三个协程打印3，第一个协程打印4这样的效果。
这道题看起来非常的复杂，博主第一次看到这个题的时候也感觉很复杂但是仔细想一下其实并没有那么复杂和上面两题的解题思路是一样的。下面我们看看这个代码如何实现

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    maxVal := 10
    res := 0                        //用于打印数字
    N := 3                          //协程的数量
    exitChan := make(chan struct{}) //用于退出
    chanArr := make([]chan struct{}, N)
    for i := 0; i < N; i++ {
        //使用无缓冲的channel
        chanArr[i] = make(chan struct{}, 1)
    }
    num := 0 //记录轮到那个协程开始打印了
    chanArr[0] <- struct{}{}
    for i := 0; i < N; i++ {
        go func(i int) {
            for {
                <-chanArr[i]
                if res >= maxVal {
                    exitChan <- struct{}{}
                    break
                }
                fmt.Printf("第%d个协程打印%d\n", i, res)
                if num == N-1 {//已经循环一轮了轮到第0个协程打印数据了
                    num = 0
                } else {
                    num++
                }
                res++
                chanArr[num] <- struct{}{} //第num个协程可以打印数据了
 
            }
 
        }(i)
    }
    <-exitChan
    for i := 0; i < N; i++ {
        close(chanArr[i]) //将管道全部关闭否则会有协程泄漏
    }
 
}

其实也非常的简单也是利用channel来进行这个协程之间的通信，由于是N个协程之间进行通信所以了我们定义一个channel的切片首先往第一个channel当中写入一个数据其他管道没有写入数据那么最先打印的一定是这个第一个协程然后我们在利用一个计数器通知其他协程打印。最后需要注意的是主协程退出时需要将管道全部关闭否则其他协程一致阻塞在那里就会引起协程泄漏,就只能等到gc的时候才能回收。

交替打印字符和数字

问题描述: 使用两个 goroutine 交替打印序列，一个 goroutinue 打印数字， 另外一个goroutine打印字母， 最终效果如下 12AB34CD56EF78GH910IJ 。

如果铁子们上面两题会了那么这道题就是有手就行的那种和第一道题没有啥区别

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
func main() {
    numChan := make(chan struct{}, 1)
    chChan := make(chan struct{}, 1)
    defer close(numChan)
    defer close(chChan)
    var wg sync.WaitGroup
    wg.Add(2)
    numChan <- struct{}{}
    go func() {
        defer wg.Done()
        for num := 1; num <= 26; num++ {
            <-numChan
            fmt.Printf("%d", num)
            chChan <- struct{}{}
        }
    }()
 
    go func() {
        defer wg.Done()
        for ch := 'A'; ch <= 'Z'; ch++ {
            <-chChan
            fmt.Printf("%s", string(ch))
            numChan <- struct{}{}
        }
    }()
    wg.Wait()
 
}

同样的也是利用这个channe进行通信，利用有缓冲的channel进行通信。当然也能使用这个无缓冲的channel进行通信

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
func main() {
    numChan := make(chan struct{})
    defer close(numChan)
    var wg sync.WaitGroup
    wg.Add(2)
    go func() {
        defer wg.Done()
        for num := 1; num <= 26; num++ {
            numChan <- struct{}{}
            fmt.Printf("%d", num)
 
        }
    }()
 
    go func() {
        defer wg.Done()
        for ch := 'A'; ch <= 'Z'; ch++ {
            <-numChan
            fmt.Printf("%s", string(ch))
        }
    }()
    wg.Wait()

交替打印字符串

题目描述，给定一个字符串使用两个协程交替打印它。
如果老铁们上面的拿到题都会了这道题不就是和第一道题是这个一模一样的吗？废话不多说直接上代码

方法一使用无缓冲的channel

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
func main() {
    chChan := make(chan struct{})
    defer close(chChan)
    var wg = new(sync.WaitGroup)
    wg.Add(2)
 
    str := "hello world"
    N := len(str)
    go func() {
        defer wg.Done()
        for i := 0; i < N; i++ {
            chChan <- struct{}{}
            if i%2 == 0 {
                fmt.Println(string(str[i]))
            }
        }
    }()
 
    go func() {
        defer wg.Done()
        for i := 0; i < N; i++ {
            <-chChan
            if i%2 == 1 {
                fmt.Println(string(str[i]))
            }
        }
    }()
    wg.Wait()
 
}

当然也可以使用有缓冲的channel在这里铁子们可以自行编写上面写的太多了。

三个协程打印ABC

题目描述使用三个协程分别打印A,B,C打印这个100次。
本题的难度和上面那几个题完全是一个货色，我们可以使用三个有缓冲的channel就可以达到目的了。具体细节请看代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    Achan := make(chan struct{}, 1)
    Bchan := make(chan struct{}, 1)
    Cchan := make(chan struct{}, 1)
    defer close(Achan)
    defer close(Bchan)
    defer close(Cchan)
    Achan <- struct{}{}
    counter := 0
    maxVal := 10
    exitChan := make(chan struct{}) //用于退出
    go func() {
        for {
            <-Achan
            if counter >= maxVal {
                exitChan <- struct{}{}
                break
            }
            fmt.Printf("%s ", "A")
            counter++
            Bchan <- struct{}{}
        }
    }()
 
    go func() {
        for {
            <-Bchan
            if counter >= maxVal {
                exitChan <- struct{}{}
                break
            }
            fmt.Printf("%s ", "B")
            counter++
            Cchan <- struct{}{}
        }
    }()
 
    go func() {
        for {
            <-Cchan
            if counter >= maxVal {
                exitChan <- struct{}{}
                break
            }
            fmt.Printf("%s ", "C")
            counter++
            Achan <- struct{}{}
        }
    }()
 
    <-exitChan
}

在这里需要注意的点是我们需要close掉这个管道当达到临界值时，主协程退出但是defer方法会执行这个时候管道一关闭所有协程都会收到退出信号，另外两个阻塞在那里的协程就会退出这样就没有这个协程泄漏了。

并发将多个文件合并到一个文件当中

MergeFile 把多个文件合成一个文件，并发实现子协程优雅退出。采用并发的方式
本题的解题思路同样的也非常的简单我们可以定义一个管道并发的读取文件写入到管道当中然后再并发的写入到文件当中。非常的简单

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
package main
 
import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strconv"
    "sync"
)
 
// MergeFile 把多个文件合成一个文件，并发实现子协程优雅退出
 
var fileChan = make(chan string, 10000)
var writeFish = make(chan struct{})
var wg sync.WaitGroup
 
func readFile(fileName string) {
    fin, err := os.Open(fileName)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
 
    defer fin.Close()
    defer wg.Done()
    reader := bufio.NewReader(fin)
    for {
        line, err := reader.ReadString('\n') //注意已经包含换行符了
        if err != nil {
            if err == io.EOF {
                if len(line) > 0 {
                    line += "\n"
                    fileChan <- line
                }
                break
            } else {
                fmt.Println(err)
                break
            }
        } else if line == "\r\n" {
            fmt.Println("进来")
            continue
        } else {
            fileChan <- line
        }
    }
 
}
func writeFile(fileName string) {
    fout, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer fout.Close()
    defer func() {
        close(writeFish)
    }()
    writer := bufio.NewWriter(fout)
    //LOOP:
    //    for {
    //        select {
    //        case <-readFish:
    //            close(fileChan)//注意需要关闭因为已经没有人往里面写了
    //            for line:=range fileChan{
    //                writer.WriteString(line) //读取时候已经包含换行符了
    //            }
    //            break LOOP
    //        case line := <-fileChan:
    //            writer.WriteString(line) //读取时候已经包含换行符了
    //        }
    //
    //    }
    for {
        if line, ok := <-fileChan; ok {
            if line != "\r\n" {
                writer.WriteString(line)
            }
        } else {
            break
        }
    }
    writer.Flush() //刷新
 
}
 
func main() {
    wg.Add(3)
    for i := 1; i <= 3; i++ {
        fileName := "Dir/" + strconv.Itoa(i)
        go readFile(fileName)
    }
 
    go writeFile("Dir/merge")
    wg.Wait()
    close(fileChan)
    <-writeFish
 
}

Channel练习

启动一个协程生成100个数发送到ch1管道当中，再启动一个协程从ch1当中取值然后计算平方将其放入ch2管道当中主协程打印

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main
 
import (
    "fmt"
    "sync"
)
 
var wg sync.WaitGroup
 
func f1(ch1 chan int) {
    defer wg.Done()
    for i := 0; i < 50; i++ {
        ch1 <- i
    }
    close(ch1)
}
func f2(ch2 chan int, ch1 chan int) {
    defer wg.Done()
    defer close(ch2)
    for x := range ch1 {
        ch2 <- x * x
    }
}
func main() {
    wg.Add(2)
    a := make(chan int, 50)
    b := make(chan int, 50)
    go f1(a)
    go f2(b, a)
    wg.Wait()
    for x := range b {
        fmt.Println(x)
    }
 
}

到此这篇关于Golang协程常见面试题小结的文章就介绍到这了,更多相关Golang协程面试题内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/qq_56999918/article/details/129214882

  • golang
  • 协程
  • 面试题

    • 延伸 · 阅读

    精彩推荐
    • GolangSingleFlight模式的Go并发编程学习

      SingleFlight模式的Go并发编程学习

      这篇文章主要为大家介绍了SingleFlight模式的Go并发编程学习，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪...

      kevwan10792022-09-29
    • Golang基于go interface{}==nil 的几种坑及原理分析

      基于go interface{}==nil 的几种坑及原理分析

      这篇文章主要介绍了基于go interface{}==nil 的几种坑及原理分析，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      mukebb7112021-05-27
    • GolangGolang标准库unsafe源码解读

      Golang标准库unsafe源码解读

      这篇文章主要为大家介绍了Golang标准库unsafe源码解读，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪...

      大摩羯先生4012022-11-08
    • GolangMac下Vs code配置Go语言环境的详细过程

      Mac下Vs code配置Go语言环境的详细过程

      这篇文章给大家介绍Mac下Vs code配置Go语言环境的详细过程，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友参考下...

      轻荇9132021-08-16
    • Golang服务器端Go程序对长短链接的处理及运行参数的保存

      服务器端Go程序对长短链接的处理及运行参数的保存

      这篇文章主要介绍了服务器端Go程序对长短链接的处理及运行参数的保存,这里针对使用Go语言编写的Socket服务器进行实例说明,需要的朋友可以参考下 ...

      G1SLu2862020-04-29
    • Golangvim配置go语言语法高亮问题的解决方法

      vim配置go语言语法高亮问题的解决方法

      vim配置go语言语法高亮的问题已经遇到过好几次了，每次都是找不到答案，今天小编给大家带来了vim配置go语言语法高亮问题的解决方法，感兴趣的朋友一起...

      Mike_Zhang5472020-05-13
    • GolangGo语言ORM框架构造查询条件示例详解

      Go语言ORM框架构造查询条件示例详解

      这篇文章主要为大家介绍了Go语言ORM框架构造查询条件示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪...

      haming6782022-12-22
    • GolangGolang try catch与错误处理的实现

      Golang try catch与错误处理的实现

      社区不少人在谈论 golang 为毛不用try/catch模式，而采用苛刻的recovery、panic、defer组合，本文就来详细的介绍一下，感兴趣的可以了解一下...

      七八月份的太阳11522021-08-12
    最近更新
    编辑推荐
    阅读排行
    热门标签
    游乐场 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2023 脚本之家 | 服务器之家(www.tuohang.net)旗下站点 版权所有关于我们联系我们版权申明网站地图