【面试宝典】19道Go机制高频题库整理(附答案背诵版)

原创

已于 2024-11-21 23:47:03 修改 · 7.4k 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#面试 #golang #职场和发展

于 2024-06-10 13:30:45 首次发布

如何解决Golang uint 类型溢出问题？

Golang的uint类型溢出问题通常会在大量运算中发生，特别是在涉及到大量循环或者大数运算时。当uint类型的值超过其最大值时，它会发生溢出，然后从该类型的最小值开始循环。为了解决这个问题，我们可以采取以下几种方法：

使用更大的数据类型：例如，如果你正在使用uint32，你可以尝试升级到uint64。这将提供更大的值范围，从而减少溢出的可能性。
添加溢出检查：在每次运算之后，你可以检查结果是否小于任一操作数（假设我们只在正数上进行操作）。如果是这样，那么就发生了溢出。

例如：

func addUint32(a, b uint32) (uint32, error) {
   
   
    res := a + b
    if res < a || res < b {
   
   
        return 0, errors.New("uint32 overflow")
    }
    return res, nil
}

使用 math/big 包：对于非常大的数值，你也可以考虑使用 math/big 包中的 Int 类型。这个类型可以处理任意大小的数值，但是运算速度会慢一些。

例如：

import "math/big"

func addBigNumbers(a, b *big.Int) *big.Int {
   
   
    res := new(big.Int)
    res.Add(a, b)
    return res
}

这些方法可以帮助你避免Golang中的uint类型溢出问题。然而，必须注意，这也会增加代码的复杂性和运行时间，因此在编写代码时，你需要权衡这些因素。

请说一下Golang map 使用注意的点，以及是否并发安全？

Go语言的map是一种非常方便的数据结构，它提供了快速的查找、插入、删除操作。然而，在使用Go语言map时，我们需要注意以下几点：

map是引用类型，如果两个map同时指向一个底层，那么一个map的变动会影响到另一个map。
map的零值（Zero Value）是nil，对nil map进行任何添加元素的操作都会触发运行时错误（panic）。因此，使用前必须先创建map，使用make函数，例如：m := make(map[string]int)。
map的键可以是任何可以用==或!=操作符比较的类型，如字符串，整数，浮点数，复数，布尔等。但是，slice，map，和function类型不可以作为map的键，因为这些类型不能使用==或!=操作符进行比较。
map在使用过程中不保证遍历顺序，即：map的遍历结果顺序可能会不一样，所以在需要顺序的场合，要自行处理数据并排序。
map进行的所有操作，包括读取，写入，删除，都是不安全的。也就是说，如果你在一个goroutine中修改map，同时在另一个goroutine中读取map，可能会触发“concurrent map read and map write”的错误。

关于并发安全，Go语言的map不是并发安全的。并发情况下，对map的读和写操作需要加锁，否则可能会因为并发操作引起的竞态条件导致程序崩溃。为了在并发环境下安全使用map，可以使用Go语言的sync包中的sync.RWMutex读写锁，或者使用sync.Map。

举个例子，如果你有一个map用于缓存数据，在多个goroutine中都可能访问和修改这个map，这时你需要使用锁来保证并发安全，代码可能如下：

var m = make(map[string]int)
var mutex = &sync.RWMutex{
   
   }

// 写入数据到map
func write(key string, value int) {
   
   
    mutex.Lock()
    m[key] = value
    mutex.Unlock()
}

// 从map中读取数据
func read(key string) (int, bool) {
   
   
    mutex.RLock()
    defer mutex.RUnlock()
    value, ok := m[key]
    return value, ok
}

在这个例子中，我们使用sync.RWMutex读写锁来保护map，在读取map时使用读锁，在写入map时使用写锁，这样就可以在并发环境下安全的使用map了。

Go 可以限制运行时操作系统线程的数量吗？

是的，Go语言可以限制运行时操作系统线程的数量。Go语言的运行时系统使用了自己的调度器，该调度器使用了M:N模型，也就是说，M个goroutine可以在N个操作系统线程上进行调度。我们可以通过设置环境变量GOMAXPROCS或使用runtime包中的GOMAXPROCS函数来限制Go程序可以使用的操作系统线程数。默认情况下，GOMAXPROCS的值为系统的CPU核数。

例如，如果我们想限制Go程序使用的操作系统线程数为2，我们可以这样做：

package main

import (
	"fmt"
	"runtime"
)

func main() {
   
   
	runtime.GOMAXPROCS(2) // 设置Go程序可以使用的最大操作系统线程数为2

	// 现在我们的Go程序最多只会使用2个操作系统线程。
}

注意，虽然GOMAXPROCS可以限制Go程序可以使用的操作系统线程数，但这并不意味着应该随意设置这个值。在大多数情况下，让Go运行时自动决定使用多少个操作系统线程可以获得最好的性能。

在实际应用中，比如你的Go程序在一个CPU核数非常多而且都处于高负载的机器上运行，你可能会希望限制Go程序使用的操作系统线程数，以防止过度竞争CPU资源。

什么是协程泄露？

协程泄露（Goroutine leakage）是指在Go程序中，启动的协程（goroutine）没有正确地停止和释放，这会导致系统资源（如内存）的持续消耗，进而可能影响到程序的性能，甚至导致程序崩溃。

协程泄露的原因通常有两种：

有些协程在完成它们的工作后没有被正确地停止。
有些协程因为阻塞（例如，等待永远不会到来的通道信息）而无法退出。

以下是一个协程泄露的例子：

func leakyFunction() {
   
   
    ch := make(chan int)

    go func() {
   
   
        val := 0
        for {
   
   
            ch <- val
            val++
        }