Golang协程常见面试题小结

更新时间：2023年02月28日 10:42:00 作者：一个山里的少年

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

交替打印奇数和偶数

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

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

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

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这样的效果。
这道题看起来非常的复杂，博主第一次看到这个题的时候也感觉很复杂但是仔细想一下其实并没有那么复杂和上面两题的解题思路是一样的。下面我们看看这个代码如何实现

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 。

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

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进行通信

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

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就可以达到目的了。具体细节请看代码

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

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管道当中主协程打印

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协程面试题内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Go语言中log日志库的介绍
本文给大家介绍Go语言中log日志库的概念使用技巧，log包定义了Logger类型，该类型提供了一些格式化输出的方法，本文通过示例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友参考下吧
2021-10-10
Go语言k8s kubernetes使用leader election实现选举
这篇文章主要为大家介绍了Go语言 k8s kubernetes 使用leader election选举，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-10-10
Go语言中的基础数据类型使用实例
这篇文章主要为大家介绍了Go中的基础数据类型使用示例解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-04-04
Hugo 游乐场内容初始化示例详解
这篇文章主要为大家介绍了Hugo 游乐场内容初始化示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-02-02
Go中的应用配置管理详解
这篇文章主要为大家介绍了Go中的应用配置管理详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-09-09
go-zero源码阅读之布隆过滤器实现代码
布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难，这篇文章主要介绍了go-zero源码阅读-布隆过滤器,需要的朋友可以参考下
2023-02-02
Go语言之重要数组类型切片(slice)make,append函数解读
这篇文章主要介绍了Go语言之重要数组类型切片(slice)make,append函数用法,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-09-09
Go编译原理之函数内联
这篇文章主要为大家介绍了Go编译原理之函数内联示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-08-08
使用go求幂的几种方法小结
这篇文章主要介绍了使用go求幂的几种方法小结，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2020-12-12
Go语言标准错误error全面解析
Go语言中的错误处理是通过内置的error接口来实现的,其中errorString和wrapError是两种常见的错误类型实现方式,errorString通过errors.New()方法实现,而wrapError则通过fmt.Errorf()方法实现,支持错误的嵌套和解析
2024-10-10