当前位置： 首页 > backend >正文

深信服golang面经

backend 2025/5/21 6:17:26

在这里插入图片描述

for range 中赋值的变量，这个变量指向的是真实的地址吗，还是临时变量

不是真实地址，是临时变量

package mainimport "fmt"func main() {slice := []int{4, 2, 3}for _, v := range slice {fmt.Println(v, &v) // 这里的 v 是临时变量}for i := range slice{fmt.Println(i, &i)fmt.Println(slice[i], &slice[i])}fmt.Println("sjhdjaskhdjkashdkas")for _, v := range slice {fmt.Println(v, &v) // 这里的 v 是临时变量}for i := range slice{fmt.Println(i, &i)fmt.Println(slice[i], &slice[i])}
}

如果在for range里面有一个函数，这个函数需要传一个指针，这时候应该怎么写，这时候会进行拷贝吗

slice内容未改变， 换成另一个方法才会改变
for _,v := range x
是值拷贝

package mainimport "fmt"func main() {slice := []int{4, 2, 3}for _,v := range slice{fmt.Println(v, &v)doDubole(&v)fmt.Println(v, &v)}fmt.Println(slice)
}func doDubole(x *int){fmt.Println(*x, x)*x = *x*2
}

有用过go link？那么在什么情况下如果我不赋给一个新的变量，它也是没问题的？

在 Go 语言中，link 通常指的是链接操作，主要用于将多个包和可执行文件组合成一个单一的可执行文件。

如果我要在defer里面修改return里面的值呢？这时怎么写？

命名返回值
返回110

package mainimport "fmt"func main() {ans := get(10)fmt.Println(ans)
}
func get(x int)(ans int){defer func(){ans += 10}()ans = x*10return
}

map时协程安全吗？有什么是协程安全的？

在 Go 中，map 不是协程安全的。如果多个协程同时读写同一个 map，可能会导致数据竞争和不确定的行为。因此，使用 map 时需要确保并发安全。

协程安全的解决方案：

  1. 使用 sync.Mutex 或 sync.RWMutex：

    • 通过互斥锁确保对 map 的访问是安全的。
    var mu sync.Mutex
m := make(map[string]int)func safeWrite(key string, value int) {mu.Lock()m[key] = valuemu.Unlock()
}func safeRead(key string) int {mu.Lock()value := m[key]mu.Unlock()return value
}

  2. 使用 sync.Map：

    • Go 提供了一个内置的并发安全的 map 类型 sync.Map，适合并发读写。
    var m sync.Map// 存储值
m.Store("key", 42)// 读取值
value, ok := m.Load("key")

  3. 使用通道 (Channels)：

    • 通过通道来同步对数据的访问，而不是直接操作 map。
    type request struct {key   stringvalue intreply chan int
}func mapHandler(requests <-chan request) {m := make(map[string]int)for req := range requests {m[req.key] = req.valuereq.reply <- m[req.key]}
}

总结：

  • map 在并发环境下不安全。
  • 使用互斥锁、sync.Map 或通道可以实现协程安全。

channel有缓冲区和无缓冲区的区别？

无缓冲：必须有人接收才能发送，需要保证顺序性
在这里插入图片描述
以下是有缓冲区和无缓冲区通道的实际应用场景示例。

1. 有缓冲区的通道：任务队列

在一个工作池中，多个工作者从一个任务队列中获取任务。使用有缓冲区的通道可以存储一定数量的任务，提高效率。

package mainimport ("fmt""time"
)func worker(id int, tasks <-chan int) {for task := range tasks {fmt.Printf("工作者 %d 处理任务 %d\n", id, task)time.Sleep(time.Second) // 模拟任务处理时间}
}func main() {tasks := make(chan int, 5) // 创建一个缓冲区为 5 的通道// 启动多个工作者for i := 1; i <= 3; i++ {go worker(i, tasks)}// 发送任务for i := 1; i <= 10; i++ {fmt.Printf("发送任务 %d\n", i)tasks <- itime.Sleep(500 * time.Millisecond) // 模拟任务生成时间}close(tasks) // 关闭通道time.Sleep(5 * time.Second) // 等待所有任务完成
}

2. 无缓冲区的通道：同步信号

在两个 goroutine 之间使用无缓冲区通道进行同步，确保一个 goroutine 在另一个完成后再继续执行。

package mainimport ("fmt"
)func main() {done := make(chan struct{}) // 创建一个无缓冲区的信号通道go func() {fmt.Println("工作者正在处理任务...")// 模拟任务处理// ...done <- struct{}{} // 发送完成信号}()// 等待工作者完成<-donefmt.Println("任务完成，主程序继续执行。")
}

总结

  • 有缓冲区的通道适用于任务队列等场景，可以提高并发性能。
  • 无缓冲区的通道适用于需要同步的场景，确保操作的顺序。

我能不能在写入channel的时候，先判断它阻不阻塞再写？

在 Go 中，无法直接检查一个通道是否会阻塞。通道的发送和接收都是阻塞操作，具体行为取决于通道的状态和接收方是否准备好。

解决方案

如果你想在写入通道之前判断是否会阻塞，可以使用非阻塞发送配合 select 语句。例如：

package mainimport ("fmt"
)func main() {ch := make(chan int, 1) // 创建一个缓冲通道，容量为 1// 先尝试发送select {case ch <- 42: // 非阻塞发送fmt.Println("写入成功")default:fmt.Println("通道已满，写入阻塞")}// 再次尝试发送select {case ch <- 99:fmt.Println("写入成功")default:fmt.Println("通道已满，写入阻塞")}// 从通道读取值value := <-chfmt.Println("读取值:", value)
}

关键点：

  1. select 语句：允许你进行非阻塞操作。
  2. default 分支：在通道不能发送或接收时执行，避免阻塞。

通过这种方式，你可以在写入通道之前判断通道的状态，从而避免阻塞。

mutex是个悲观锁还是乐观锁，乐观锁和悲观锁的区别？

Mutex 是悲观锁，适用于高冲突的场景。
乐观锁 适用于低冲突的场景，减少了加锁带来的性能开销。

需要知道一个goroutine里面的一个函数是否执行成功还是失败，应该怎么写

要在一个 goroutine 中检查一个函数是否执行成功，可以使用通道（channel）来传递结果或错误信息。以下是一个示例，演示如何实现这一点：

示例代码

package mainimport ("errors""fmt""time"
)func doWork(resultChan chan<- string, errChan chan<- error) {// 模拟一些工作time.Sleep(2 * time.Second)// 假设工作成功，返回结果// resultChan <- "工作成功"// 假设工作失败，返回错误errChan <- errors.New("工作失败")
}func main() {resultChan := make(chan string)errChan := make(chan error)go doWork(resultChan, errChan)select {case result := <-resultChan:fmt.Println("结果:", result)case err := <-errChan:fmt.Println("错误:", err)case <-time.After(3 * time.Second): // 设置超时fmt.Println("操作超时")}
}

关键点

  1. 通道：

    • 使用 resultChan 来传递成功结果。
    • 使用 errChan 来传递错误信息。

  2. select 语句：

    • 通过 select 等待通道中的结果或错误。
    • 如果有结果返回，则打印结果；如果有错误返回，则打印错误。

  3. 超时处理：

    • 可以使用 time.After 设置超时处理，避免等待太久。

通过这种方式，你可以有效地在 goroutine 中检查函数的执行状态。

了解过Go的内存逃逸吗？

是的，Go 的内存逃逸（Escape Analysis）是一个重要的功能，用于优化内存分配和管理。

什么是内存逃逸？

内存逃逸指的是在 Go 中某个变量的生命周期超出了其原本的作用域。这意味着该变量不能在栈上分配，而必须在堆上分配，以确保在函数返回后仍然能够访问。

如何工作？

  1. 栈 vs 堆：

    • 栈：用于存储局部变量，分配和释放速度快，但生命周期受限于函数调用。
    • 堆：用于动态分配内存，生命周期更长，但分配和释放速度较慢。

  2. 逃逸分析：

    • Go 编译器会在编译时分析变量的使用情况，判断它是否会“逃逸”到堆上。
    • 如果变量的地址被返回，或在函数外部使用，它将被分配到堆上。

示例

以下是一个简单的例子，展示了内存逃逸的情况：

package mainimport "fmt"type Person struct {Name string
}func NewPerson(name string) *Person {return &Person{Name: name} // 逃逸到堆
}func main() {p := NewPerson("Alice")fmt.Println(p.Name)
}

在上面的代码中，NewPerson 函数返回一个指向 Person 结构体的指针，这导致 Person 实例被分配到堆上，因为它的生命周期超出了函数的作用域。

逃逸分析的好处

  • 性能优化：通过避免不必要的堆分配，提升性能。
  • 内存管理：减少内存泄漏的风险，帮助开发者更好地管理内存。

如何检查逃逸分析

可以使用 go build -gcflags -m 命令来查看编译器的逃逸分析信息：

go build -gcflags -m yourfile.go

这将显示哪些变量逃逸到堆上，以及相关的分析信息。

总结

内存逃逸分析是 Go 的一项重要特性，帮助编译器优化内存分配，提高程序性能。理解内存逃逸有助于编写更高效的 Go 代码。

场景：1GB文件，每个单词不超过16字节，在1M的内存里，得到出现频率最高的100个单词

由于文件大小为1GB，而内存的大小只有1MB，因此不能一次把所有的词读入到内存中去处理，可以采用分治的方法进行处理：把一个文件分解为多个小的子文件，从而保证每个文件的大小都小于1MB，进而可以直接被读取到内存中处理。

第一步：使用多路归并排序对大文件进行排序，这样相同的单词肯定是挨着的

第二步：
① 初始化一个 100 个节点的小顶堆，用于保存 100 个出现频率最多的单词
② 遍历整个文件，一个单词一个单词的从文件中取出来，并计数
③ 等到遍历的单词和上一个单词不同的话，那么上一个单词及其频率如果大于堆顶的词的频率，那么放在堆中，否则不放

最终，小顶堆中就是出现频率前 100 的单词了

多路归并排序对大文件进行排序的步骤如下：
① 将文件按照顺序切分成大小不超过 512KB 的小文件，总共 2048 个小文件
② 使用 1MB 内存分别对 2048 个小文件中的单词进行排序
③ 使用一个大小为 2048 大小的堆，对 2048 个小文件进行多路排序，结果写到一个大文件中

json和protobuf的区别

JSON（JavaScript Object Notation）和 Protobuf（Protocol Buffers）是两种常用的数据序列化格式。它们各自有不同的特点和适用场景。以下是它们之间的主要区别：

1. 数据格式

  • JSON：

    • 人类可读的文本格式，易于调试和查看。
    • 数据使用键值对的结构表示，支持基本数据类型（字符串、数字、布尔值、数组和对象）。

  • Protobuf：

    • 二进制格式，不易于人类直接阅读。
    • 需要预先定义数据结构（消息格式）并编译生成代码来处理数据。

2. 性能

  • JSON：

    • 解析和序列化速度较慢，因为它是文本格式。
    • 数据体积相对较大，尤其是在传输大量数据时。

  • Protobuf：

    • 解析和序列化速度快，效率高。
    • 数据体积较小，适合网络传输和存储。

3. 可扩展性

  • JSON：

    • 结构灵活，不需要预定义模式，可以随意添加字段，但对版本控制支持较差。

  • Protobuf：

    • 需要预定义结构，但支持向后兼容和向前兼容，可以安全地添加或删除字段。

4. 语言支持

  • JSON：

    • 几乎所有编程语言都支持 JSON 解析和生成。

  • Protobuf：

    • 支持多种编程语言，但需要使用特定的工具生成代码。

5. 使用场景

  • JSON：

    • 适用于配置文件、Web API（如 RESTful API）、轻量级数据传输等场景。

  • Protobuf：

    • 适用于高性能网络通信、大规模数据存储、微服务架构等场景。

总结

  • JSON：易读、灵活，但性能较低，适合简单的应用场景。
  • Protobuf：高效、可扩展，适合对性能和数据体积有较高要求的应用场景。

Go怎么调试的，会Goland远程调试吗？

  1. 安装dlv
    在Linux服务器上执行：go install github.com/go-delve/delve/cmd/dlv@latest，安装dlv调试工具，因为是go编译的可执行程序，可以随意复制，其他环境甚至都可以不安装go语言环境。

  2. 按照goland提示添加远程调试

  3. 添加编译配置

  4. 在服务器运行
    将可执行程序上传到服务器,并使用dlv运行：
    dlv --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec ./test001_linux

带命令行参数,在可执行程序后面带上 --，再后面就是命令行参数：

dlv --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec ./test001_linux – -s 123

  1. 然后再window的goland上运行调试

算法：查找字符串子串，有哪些算法？

暴力匹配：简单，但效率低。
KMP：高效，适合单个子串匹配。O(m+n)
部分匹配表（LPS 数组）：

在开始匹配之前，KMP 算法首先构建一个部分匹配表（Longest Prefix Suffix，LPS）。
LPS 数组的每个元素 lps[i] 表示子串 pattern[0…i] 中的最长相等前后缀的长度。
LPS 数组可以帮助我们在匹配失败时，不必回溯主串的指针，而是根据已匹配的部分直接跳到下一个可能匹配的位置。
匹配过程：

使用两个指针，i 指向主串，j 指向子串。
逐个比较主串和子串的字符：
如果字符匹配，两个指针同时向后移动。
如果不匹配且 j > 0，则根据 LPS 数组调整子串指针 j，而不移动主串指针 i。
如果 j 达到子串的长度，说明找到匹配，记录匹配位置。

http://www.xdnf.cn/news/7611.html

相关文章：

  • 【Python 算法零基础 4.排序 ③ 插入排序】
  • 零基础入门Selenium自动化测试：自动登录edu邮箱
  • waitress 简介
  • Dify实战案例《AI面试官》更新，支持语音交互+智能知识库+随机题库+敏感词过滤等...
  • 5月20日day31打卡
  • 自定义geojson生成物体的样式
  • Pichome 开源网盘程序index.php 文件读取漏洞(CVE-2025-1743)
  • 完善网络安全等级保护，企业需注意：
  • （2）JVM 内存模型更新与 G1 垃圾收集器优化
  • SymPy|主元、重新表示、分数、约分表达式、极限、级数、ode、获取值、输出形式
  • BRIGHTONE : 520-On-Chain WOHOO Carnival
  • 学习日记-day11-5.20
  • 【强化学习】深度强化学习 - Deep Q-Network（DQN）算法
  • 代码随想录算法训练营Day59
  • 谷歌宣布推出 Android 的新安全功能，以防止诈骗和盗窃
  • HarmonyOS5云服务技术分享--账号关联开发指南
  • 蓝桥杯框架-按键数码管
  • 使用Java实现Navicat密码的加密与解密
  • 渐开线少齿差传动学习笔记
  • 集星獭 | 重塑集成体验：新版编排重构仿真电商订单数据入库
  • 更新2011-2025经济类联考 396-真题+解析 PDF
  • 30天自制操作系统day5（vram和显存）（GDT和IDT）（c语言结构体）（汇编-c）（ai辅助整理）
  • [Web服务器对决] Nginx vs. Apache vs. LiteSpeed：2025年性能、功能与适用场景深度对比
  • 第5天-python饼图绘制
  • 系统集成项目管理工程师学习笔记之启动过程组
  • 防御策略与安全加固
  • 电子科技大学软件工程实践期末
  • OK536N-C测评:开箱体验以及在Linux下如何管理开发板
  • MacBook Air A2179（Intel版）安装macOS Catalina所需时间
  • 谷歌云服务器稳不稳？