扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > GO >Golang协程常见面试题小结
  • 143

0
分享到

Golang协程常见面试题小结

Golang协程面试题Golang协程 2023-02-28 11:02:45 143人浏览 安东尼
摘要

目录交替打印奇数和偶数方法一：使用无缓冲的channel进行协程间通信方法二：使用有缓冲的channelN个协程打印1到maxVal交替打印字符和数字交替打印字符串方法一使用无缓冲的

交替打印奇数和偶数

下面让我们一起来看看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协程面试题内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: Golang协程常见面试题小结

本文链接: https://lsjlt.com/news/197784.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Golang协程常见面试题小结
    目录交替打印奇数和偶数方法一：使用无缓冲的channel进行协程间通信方法二：使用有缓冲的channelN个协程打印1到maxVal交替打印字符和数字交替打印字符串方法一使用无缓冲的...
    99+
    2023-02-28
    Golang协程面试题 Golang协程
  • Golang协程常见面试题代码分析
    这篇文章主要介绍“Golang协程常见面试题代码分析”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“Golang协程常见面试题代码分析”文章能帮助大家解决问题。交替打印奇数和偶数使用两个gorouti...
    99+
    2023-07-05
  • TCP协议的常见面试题
    1. 为什么连接的时候是三次握手，关闭的时候却是四次握手？...
    99+
    2023-06-03
  • Android中关于Binder常见面试问题小结
    目录1.简单介绍下binder2.Binder的定向制导，如何找到目标Binder，唤起进程或者线程3.Binder中的红黑树，为什么会有两棵binder_ref红黑树4.Binde...
    99+
    2024-04-02
  • 微信小程序常见面试题有哪些
    这篇文章主要介绍了微信小程序常见面试题有哪些的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇微信小程序常见面试题有哪些文章都会有所收获，下面我们一起来看看吧。1.在小程序中如何获取用户信息？（1）小程序为升级前：...
    99+
    2023-06-30
  • pycharm中TensorFlow调试常见问题小结
    目录1.RuntimeError:AttemptedtouseaclosedSession.2.AttributeError:module‘tensorflow'hasnoattri...
    99+
    2024-04-02
  • Vue.js 常见面试题
    什么是SPA？SAP意思是 单页面应用 。SPA 是一种应用程序，它提前下载好布局，并让页面在不同布局之间切换进而无需刷新就可以渲染整个页面。与此特点相对的，它将会从服务器中获取必要信息并替换页面中对应的内容。什么是 Vue 指令Vue 指...
    99+
    2024-04-02
  • RocketMq常见面试题
    目录 1、RocketMQ Broker中的消息被消费后会立即删除吗？2、RocketMQ消费模式有几种？3、消费消息是push还是pull？4、broker如何处理拉取请求的？ ----？？...
    99+
    2023-09-03
    java-rocketmq rocketmq java
  • PHP常见面试题
    一. 基本知识点 1.1 HTTP协议中几个状态码的含义:503 500 401 403 404 200 301 302。。。 200 : 请求成功，请求的数据随之返回。 301 : 永久性重定向。 302 : 暂时行重定向。 401 : ...
    99+
    2023-09-04
    php 服务器 开发语言
  • Java并发基础常见面试题（总结）
    本篇文章给大家总结了一下Java并发基础常见面试题，有一定的参考价值，有需要的朋友可以参考一下，希望对大家有所帮助。1. 什么是线程和进程1.1. 何为进程进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程...
    99+
    2015-12-07
    java面试题 spring Java
  • 常见的Java中数据结构面试题
    常见的Java中数据结构面试题？针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。栈和队列的共同特点是（只允许在端点处插入和删除元素）4.栈通常采用的两种存储结构是（线性存储结构...
    99+
    2023-05-31
    java 数据结构 ava
  • SpringBoot常见问题小结
     1、在外部tomcat中运行 pom文件中 jar 改成 war，内置tomcat要改成provide<dependency> <groupId>org.apache.tomcat.embed</...
    99+
    2023-05-31
    spring boot 常见问题
  • Java Web常见面试题
    jsp 和 servlet 有什么区别？ （推荐学习：java常见面试题）jsp经编译后就变成了Servlet.（JSP的本质就是Servlet，JVM只能识别java的类，不能识...
    99+
    2019-08-30
    java面试题 Java
  • 常见的PHP面试题
    这篇文章将为大家详细讲解有关常见的PHP面试题，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。通过哪一个函数，可以把错误转换为异常处理？A：set_error_handlerB：error_r...
    99+
    2023-06-15
  • Java常见的面试题
    　　1)Java 中能创建 volatile 数组吗　　能，Java 中可以创建 volatile 类型数组，不过只是一个指向数组的引用，而不是整个数组。我的意思是，如果改变引用指向的数组，将会受到 volatile 的保护，但是如果多个线...
    99+
    2023-06-03
  • java的多线程常见面试题
    并行和并发有什么区别？ （推荐学习：java常见面试题）并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。...
    99+
    2018-11-10
    java面试题 java
  • Java常见面试题：java面试笔记
    基本数据类型有哪些？基本数据类型包括byte、int、char、long、float、double、boolean和short。 java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空...
    99+
    2023-06-02
  • JavaScript数据结构常见面试问题整理
    目录1.JS有哪些数据类型有什么区别2.数据类型检测的方式3.判断是否是数组的方法4.null和undefined的区别5.手写instanceof方法6.为什么0.1+0.2 !=...
    99+
    2022-11-13
    JavaScript 数据结构 JavaScript 数据结构面试问题
  • Pythonasyncio异步编程常见问题小结
    目录一、asyncio编程简单示例二、asyncio编程常见问题三、报错原因及解决方案今天继续给大家介绍Python相关知识，本文主要内容是Python asyncio异步编程常见问...
    99+
    2023-01-18
    Python asyncio 异步 Python asyncio
  • java常见面试题整理
    面向对象的特征有哪些方面 所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。 （推荐学习：java常见面试题）继承...
    99+
    2016-08-28
    java面试题 java
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作