乐趣区

关于go:精选Golang高频面试题和答案汇总

jiezi

大家好，我是阳哥。

之前写的《GO 必知必会面试题汇总》，曾经浏览破万，珍藏 230+。

也欢送大家珍藏、转发本文。

这篇文章给大家整顿了 17 道 Go 语言高频面试题和答案详解，每道题都给出了 代码示例，不便大家更好的了解。

1. 并发安全性

Go 语言中的并发安全性是什么？如何确保并发安全性？

解答：

并发安全性是指在并发编程中，多个 goroutine 对共享资源的拜访不会导致数据竞争和不确定的后果。

为了确保并发安全性，能够采取以下措施：

  • 应用互斥锁（Mutex）：通过应用互斥锁来爱护共享资源的拜访，一次只容许一个 goroutine 访问共享资源，从而防止竞争条件。
  • 应用原子操作（Atomic Operations）：对于简略的读写操作，能够应用原子操作来保障操作的原子性，防止竞争条件。
  • 应用通道（Channel）：通过应用通道来进行 goroutine 之间的通信和同步，防止共享资源的间接拜访。
  • 应用同步机制：应用同步机制如期待组（WaitGroup）、条件变量（Cond）等来协调多个 goroutine 的执行程序和状态。

通过以上措施，能够确保并发程序的安全性，防止数据竞争和不确定的后果。

2.defer

Go 语言中的 defer 关键字有什么作用？请给出一个应用 defer 的示例。

解答：

defer 关键字用于提早函数的执行，即在函数退出前执行某个操作。defer 通常用于开释资源、敞开文件、解锁互斥锁等清理操作，以确保在函数执行结束后进行解决。

也能够应用 defer 语句联合 time 包实现函数执行工夫的统计。

代码示例：

上面是一个应用 defer 的示例，关上文件并在函数退出前敞开文件：

package main

import (
    "fmt"
    "os"
)

func main() {file, err := os.Open("file.txt")
    if err != nil {fmt.Println("Error opening file:", err)
        return
    }

    defer func() {err := file.Close()
        if err != nil {fmt.Println("Error closing file:", err)
        }
    }()

    // 应用文件进行操作
    // ...

    fmt.Println("File operations completed")
}

在上述代码中，咱们应用 defer 关键字提早了文件的敞开操作，确保在函数执行结束后敞开文件。这样能够防止遗记敞开文件而导致资源透露。

3. 指针

面试题：Go 语言中的指针有什么作用？请给出一个应用指针的示例。

解答：

指针是一种变量，存储了另一个变量的内存地址。通过指针，咱们能够间接拜访和批改变量的值，而不是对变量进行拷贝。

指针在传递大型数据结构和在函数间共享数据时十分有用。

代码示例

上面是一个应用指针的示例，替换两个变量的值：

package main

import "fmt"

func swap(a, b *int) {
    temp := *a
    *a = *b
    *b = temp
}

func main() {
    x := 10
    y := 20
    fmt.Println("Before swap:", x, y)
    swap(&x, &y)
    fmt.Println("After swap:", x, y)
}

在上述代码中，咱们定义了一个 swap 函数，接管两个指针作为参数，并通过指针替换了两个变量的值。在主函数中，咱们通过取地址操作符 & 获取变量的指针，并将指针传递给 swap 函数。通过应用指针，咱们实现了变量值的替换。

4.map

Go 语言中的 map 是什么？请给出一个应用 map 的示例。

解答：

map 是一种无序的键值对汇合，也称为字典。map 中的键必须是惟一的，而值能够反复。map 提供了疾速的查找和插入操作，实用于须要依据键疾速检索值的场景。

代码示例：

上面是一个应用 map 的示例，存储学生的问题信息：

package main

import "fmt"

func main() {
    // 创立一个 map，键为学生姓名，值为对应的问题
    grades := make(map[string]int)

    // 增加学生的问题
    grades["Alice"] = 90
    grades["Bob"] = 85
    grades["Charlie"] = 95

    // 获取学生的问题
    aliceGrade := grades["Alice"]
    bobGrade := grades["Bob"]
    charlieGrade := grades["Charlie"]

    // 打印学生的问题
    fmt.Println("Alice's grade:", aliceGrade)
    fmt.Println("Bob's grade:", bobGrade)
    fmt.Println("Charlie's grade:", charlieGrade)
}

在上述代码中，咱们应用 make 函数创立了一个 map，键的类型为 string，值的类型为 int。而后，咱们通过键来增加学生的问题信息，并通过键来获取学生的问题。通过应用 map，咱们能够依据学生的姓名疾速查找对应的问题。

请留神，map 是无序的，每次迭代 map 的程序可能不同。

5.map 的有序遍历

map 是无序的，每次迭代 map 的程序可能不同。如果须要按特定程序遍历 map，应该怎么做呢？

解答：

在 Go 语言中，map 是无序的，每次迭代 map 的程序可能不同。如果须要按特定程序遍历 map，能够采纳以下步骤：

  1. 创立一个切片来保留 map 的键。
  2. 遍历 map，将键存储到切片中。
  3. 对切片进行排序。
  4. 依据排序后的键程序，遍历 map 并拜访对应的值。

示例代码：

以下是一个示例代码，展现如何按键的升序遍历 map：

package main

import (
    "fmt"
    "sort"
)

func main() {m := map[string]int{
        "b": 2,
        "a": 1,
        "c": 3,
    }

    keys := make([]string, 0, len(m))
    for k := range m {keys = append(keys, k)
    }

    sort.Strings(keys)

    for _, k := range keys {fmt.Println(k, m[k])
    }
}

在上述代码中，咱们创立了一个 map m，其中蕴含了键值对。而后，咱们创立了一个切片 keys，并遍历 map 将键存储到切片中。接下来，咱们对切片进行排序，应用 sort.Strings 函数对切片进行升序排序。最初，咱们依据排序后的键程序遍历 map，并拜访对应的值。

通过以上步骤，咱们能够依照特定程序遍历 map，并拜访对应的键值对。请留神，这里应用的是升序排序，如果须要降序排序，能够应用 sort.Sort(sort.Reverse(sort.StringSlice(keys))) 进行排序。

6. 切片和数组

Go 语言中的 slice 和数组有什么区别？请给出一个应用 slice 的示例。

解答：

在 Go 语言中，数组和切片（slice）都是用于存储一组雷同类型的元素。它们的区别在于长度的固定性和灵活性。数组的长度是固定的，而切片的长度是可变的。

代码示例：

上面是一个应用切片的示例，演示了如何向切片中增加元素：

package main

import "fmt"

func main() {
    // 创立一个切片
    numbers := []int{1, 2, 3, 4, 5}

    // 向切片中增加元素
    numbers = append(numbers, 6)
    numbers = append(numbers, 7, 8, 9)

    // 打印切片的内容
    fmt.Println(numbers)
}

在上述代码中，咱们应用 []int 语法创立了一个切片 numbers，并初始化了一些整数。而后，咱们应用append 函数向切片中增加元素。通过应用切片，咱们能够动静地增加和删除元素，而不须要当时指定切片的长度。

须要留神的是，切片是基于数组的一种封装，它提供了更便捷的操作和灵活性。切片的底层是一个指向数组的指针，它蕴含了切片的长度和容量信息。

以上是对于 Go 语言中切片和数组的区别以及应用切片的示例。切片是 Go 语言中罕用的数据结构，它提供了更灵便的长度和操作形式，实用于动态变化的数据汇合。

7. 切片移除元素

怎么移除切片中的数据？

解答

要移除切片中的数据，能够应用 切片的切片操作 或应用内置的 append 函数来实现。以下是两种常见的办法：

1. 应用切片的切片操作：

利用切片的切片操作，能够通过指定要移除的元素的索引地位来删除切片中的数据。

例如，要移除切片中的第三个元素，能够应用切片的切片操作将切片分为两局部，并将第三个元素从两头移除。

package main

import "fmt"

func main() {numbers := []int{1, 2, 3, 4, 5}

    // 移除切片中的第三个元素
    indexToRemove := 2
    numbers = append(numbers[:indexToRemove], numbers[indexToRemove+1:]...)

    fmt.Println(numbers) // 输入: [1 2 4 5]
}

在上述代码中，咱们应用切片的切片操作将切片分为两局部：numbers[:indexToRemove]示意从结尾到要移除的元素之前的局部，numbers[indexToRemove+1:]示意从要移除的元素之后到开端的局部。而后，咱们应用 append 函数将这两局部从新连接起来，从而实现了移除元素的操作。

2. 应用 append 函数：

另一种办法是应用 append 函数，将要移除的元素之前和之后的局部重新组合成一个新的切片。这种办法更实用于不晓得要移除的元素的索引地位的状况。

package main

import "fmt"

func main() {numbers := []int{1, 2, 3, 4, 5}

    // 移除切片中的元素 3
    elementToRemove := 3
    for i := 0; i < len(numbers); i++ {if numbers[i] == elementToRemove {numbers = append(numbers[:i], numbers[i+1:]...)
            break
        }
    }
    fmt.Println(numbers) // 输入: [1 2 4 5]
}

在上述代码中，咱们应用 for 循环遍历切片，找到要移除的元素的索引地位。一旦找到匹配的元素，咱们应用 append 函数将要移除的元素之前和之后的局部从新连接起来，从而实现了移除元素的操作。

无论是应用切片的切片操作还是应用 append 函数，都能够实现在切片中移除数据的操作。

8.panic 和 recover

Go 语言中的 panic 和 recover 有什么作用？请给出一个应用 panic 和 recover 的示例。

解答：

panic 和 recover 是 Go 语言中用于解决异样的机制。当程序遇到无奈解决的谬误时，能够应用 panic 引发一个异样，中断程序的失常执行。而 recover 用于捕捉并解决 panic 引发的异样，使程序可能继续执行。

代码示例：

上面是一个应用 panic 和 recover 的示例，解决除数为零的状况：

package main

import "fmt"

func divide(a, b int) int {defer func() {if err := recover(); err != nil {fmt.Println("Error:", err)
        }
    }()

    if b == 0 {panic("division by zero")
    }
  
    return a / b
}

func main() {result := divide(10, 0)
    fmt.Println("Result:", result)
}

执行后果如下：
`
Error: division by zero
Result: 0
`

在上述代码中，咱们定义了一个 divide 函数，用于执行除法运算。在函数中，咱们应用 panic 关键字引发一个异样，当除数为零时，会引发一个 ”division by zero” 的异样。

而后，咱们应用 defer 和recover来捕捉并解决这个异样，打印出错误信息。通过应用recover，咱们能够防止程序因为异样而解体，而是继续执行后续的代码。

9. 互斥锁

什么是互斥锁（Mutex）？在 Go 语言中如何应用互斥锁来爱护共享资源？

解答：

互斥锁是一种并发编程中罕用的同步机制，用于爱护共享资源的拜访。

在 Go 语言中，能够应用 sync 包中的 Mutex 类型来实现互斥锁。通过调用 Lock 办法来获取锁，爱护共享资源的拜访，而后在应用完共享资源后调用 Unlock 办法开释锁。

代码示例：

package main

import (
    "fmt"
    "sync"
)

var (
    counter int
    mutex   sync.Mutex
)

func increment() {mutex.Lock()
    counter++
    mutex.Unlock()}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {wg.Add(1)
        go func() {defer wg.Done()
            increment()}()}
    wg.Wait()

    fmt.Println("Counter:", counter)
}

在上述代码中，咱们定义了一个全局变量 counter 和一个 sync.Mutex 类型的互斥锁 mutex。在 increment 函数中，咱们应用 mutex.Lock()获取锁，对 counter 进行递增操作，而后应用 mutex.Unlock()开释锁。通过应用互斥锁，咱们确保了对 counter 的并发拜访的安全性。

10. 自旋

解释一下并发编程中的自旋状态？

解答：

自旋状态是并发编程中的一种状态，指的是线程或过程在期待某个条件满足时，不会进入休眠或阻塞状态，而是通过一直地查看条件是否满足来进行忙期待。

在自旋状态下，线程会重复执行一个忙期待的循环，直到条件满足或达到肯定的等待时间。 这种形式能够缩小线程切换的开销，进步并发性能。然而，自旋状态也可能导致 CPU 资源的节约，因为线程会继续占用 CPU 工夫片，即便条件尚未满足。

自旋状态通常用于以下状况：

  • 在多处理器零碎中，期待某个共享资源的开释，以防止线程切换的开销。
  • 在短暂的等待时间内，冀望条件可能疾速满足，从而防止进入阻塞状态的开销。

须要留神的是，自旋状态的应用应该审慎，并且须要依据具体的场景和条件进行评估。如果自旋工夫过长或条件不太可能很快满足，那么应用自旋状态可能会节约大量的 CPU 资源。在这种状况下，更适宜应用阻塞或休眠期待的形式。

总之，自旋状态是一种在期待条件满足时不进入休眠或阻塞状态的并发编程技术。它能够缩小线程切换的开销，但须要衡量 CPU 资源的应用和等待时间的长短。

11. 原子操作和锁

原子操作和锁的区别是什么？

原子操作和锁是并发编程中罕用的两种同步机制，它们的区别如下：

  1. 作用范畴：

    • 原子操作（Atomic Operations）：原子操作是一种根本的操作，能够在单个指令级别上执行，保障操作的原子性。原子操作通常用于对共享变量进行读取、写入或批改等操作，以确保操作的完整性。
    • 锁（Lock）：锁是一种更高级别的同步机制，用于爱护临界区（Critical Section）的拜访。锁能够用于限度对共享资源的并发拜访，以确保线程平安。

  2. 应用形式：

    • 原子操作：原子操作是通过硬件指令或特定的原子操作函数来实现的，能够间接利用于变量或内存地位，而无需额定的代码。
    • 锁：锁是通过编程语言提供的锁机制来实现的，须要显式地应用锁的相干办法或语句来爱护临界区的拜访。

  3. 粒度：

    • 原子操作：原子操作通常是针对单个变量或内存地位的操作，能够在十分细粒度的层面上实现同步。
    • 锁：锁通常是针对一段代码或一组操作的拜访进行同步，能够管制更大粒度的临界区。

  4. 性能开销：

    • 原子操作：原子操作通常具备较低的性能开销，因为它们是在硬件级别上实现的，无需额定的同步机制。
    • 锁：锁通常具备较高的性能开销，因为它们须要进行上下文切换和线程同步等操作。

综上所述，原子操作和锁是两种不同的同步机制，用于解决并发编程中的同步问题。原子操作实用于对单个变量的读写操作，具备较低的性能开销。而锁实用于对一段代码或一组操作的拜访进行同步，具备更高的性能开销。抉择应用原子操作还是锁取决于具体的场景和需要。

须要留神的是，原子操作通常用于对共享变量进行简略的读写操作，而锁更实用于对临界区的拜访进行简单的操作和爱护。在设计并发程序时，须要依据具体的需要和性能要求来抉择适合的同步机制。

12.Goroutine

Go 语言中的 goroutine 是什么？请给出一个应用 goroutine 的示例。

解答：

goroutine 是 Go 语言中轻量级的并发执行单元，能够同时执行多个 goroutine，而不须要显式地治理线程的生命周期。goroutine 由 Go 运行时（runtime）进行调度，能够在并发编程中实现并行执行。

代码示例：

上面是一个应用 goroutine 的示例，计算斐波那契数列：

package main

import (
    "fmt"
    "sync"
)

func fibonacci(n int, wg *sync.WaitGroup) {defer wg.Done()

    x, y := 0, 1
    for i := 0; i < n; i++ {fmt.Println(x)
        x, y = y, x+y
    }
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go fibonacci(10, &wg)
    go fibonacci(5, &wg)

    wg.Wait()}

在上述代码中，咱们应用 go 关键字启动了两个 goroutine，别离计算斐波那契数列的前 10 个和前 5 个数字。通过应用 goroutine，咱们能够并行地执行这两个计算工作，而不须要显式地创立和治理线程。

13. 通道

Go 语言中的通道（channel）是什么？请给出一个应用通道的示例。

解答：

通道是用于在 goroutine 之间进行通信和同步的机制。通道提供了一种平安的、阻塞的形式来发送和接收数据。通过通道，能够实现多个 goroutine 之间的数据传递和同步。

代码示例：

上面是一个应用通道的示例，计算两个数的和：

package main

import "fmt"

func sum(a, b int, c chan int) {
    result := a + b
    c <- result // 将后果发送到通道
}

func main() {
    // 创立一个整型通道
    c := make(chan int)

    // 启动一个 goroutine 来计算两个数的和
    go sum(10, 20, c)

    // 从通道接管后果
    result := <-c

    fmt.Println("Sum:", result)
}

在上述代码中，咱们定义了一个 sum 函数，用于计算两个数的和，并将后果发送到通道 c 中。在 main 函数中，咱们创立了一个整型通道 c，而后启动一个 goroutine 来执行 sum 函数，并将后果发送到通道中。最初，咱们通过从通道中接管后果，获取计算的和并打印进去。

通过应用通道，咱们实现了 goroutine 之间的数据传递和同步。在示例中，通道 c 用于将计算结果从 goroutine 发送到主 goroutine，实现了数据的传递和同步。

14.select

Go 语言中的 select 语句是什么？请给出一个应用 select 语句的示例。

解答：

select 语句是 Go 语言中用于解决通道操作的一种机制。它能够同时监听多个通道的读写操作，并在其中任意一个通道就绪时执行相应的操作。

代码示例：

上面是一个应用 select 语句的示例，从两个通道中接收数据：

package main

import "fmt"

func main() {ch1 := make(chan int)
    ch2 := make(chan int)

    go func() {ch1 <- 10}()

    go func() {ch2 <- 20}()

    select {
    case num := <-ch1:
        fmt.Println("Received from ch1:", num)
    case num := <-ch2:
        fmt.Println("Received from ch2:", num)
    }
}

在上述代码中，咱们创立了两个整型通道 ch1 和 ch2。而后，咱们启动了两个 goroutine，别离向通道 ch1 和 ch2 发送数据。在主 goroutine 中，咱们应用 select 语句监听这两个通道的读操作，并在其中任意一个通道就绪时执行相应的操作。在示例中，咱们从就绪的通道中接收数据，并打印进去。

通过应用 select 语句，咱们能够实现对多个通道的并发操作，并依据就绪的通道执行相应的操作。这在解决并发工作时十分有用。

15. 协程和通道

Go 语言如何通过 goroutine 和 channel 实现并发的？请给出一个并发编程的示例。

解答：

Go 语言通过 goroutine 和 channel 实现并发。goroutine 是一种轻量级的线程，能够同时执行多个 goroutine，而不须要显式地治理线程的生命周期。

channel 是用于 goroutine 之间通信的管道。上面是一个简略的并发编程示例，计算斐波那契数列：

代码示例

package main

import "fmt"

func fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func main() {c := make(chan int)
    go fibonacci(10, c)
    for num := range c {fmt.Println(num)
    }
}

在上述代码中，咱们应用 goroutine 启动了一个计算斐波那契数列的函数，并通过 channel 进行通信。主函数从 channel 中接管计算结果并打印。通过 goroutine 和 channel 的联合，咱们实现了并发计算斐波那契数列的性能。

16.runtime

Go 语言中的 runtime 包是用来做什么的？请给出一个应用 runtime 包的示例。

解答：

runtime 包是 Go 语言的运行时零碎，提供了与底层零碎交互和管制的性能。它蕴含了与内存治理、垃圾回收、协程调度等相干的函数和变量。

代码示例：

上面是一个应用 runtime 包的示例，获取以后 goroutine 的数量：

package main

import (
    "fmt"
    "runtime"
)

func main() {num := runtime.NumGoroutine()
    fmt.Println("Number of goroutines:", num)
}

17. 垃圾回收

Go 语言中的垃圾回收是如何工作的？请给出一个应用垃圾回收的示例。

解答：

Go 语言中的垃圾回收器（Garbage Collector）是主动治理内存的机制，用于回收不再应用的内存。垃圾回收器会自动检测不再应用的对象，并开释其占用的内存空间。

代码示例

上面是一个应用垃圾回收的示例，创立一个大量的长期对象：

package main

import (
    "fmt"
    "runtime"
    "time"
)

func createObjects() {
    for i := 0; i < 1000000; i++ {_ = make([]byte, 1024)
    }
}

func main() {createObjects()
    time.Sleep(time.Second) // 期待垃圾回收器执行

    var stats runtime.MemStats
    runtime.ReadMemStats(&stats)
    fmt.Println("Allocated memory:", stats.Alloc)
}

打印后果：
`
Allocated memory: 77344
`

在上述代码中，咱们通过循环创立了大量的长期对象。而后，咱们应用 time.Sleep 函数期待垃圾回收器执行。最初，咱们应用 runtime.ReadMemStats 函数读取内存统计信息，并打印出已调配的内存大小。

通过应用垃圾回收器，咱们能够主动治理内存，防止手动开释不再应用的对象。垃圾回收器会在适当的机会主动回收不再应用的内存，从而进步程序的性能和可靠性。

总结

咱们在答复面试题的时候，不能水灵灵的去背八股文，肯定要联合利用场景，最好能联合过来做过的我的项目，去和面试官沟通。

这些场景题尽管不要求咱们手撕代码，然而解决思路和要害办法还是要烂熟于心的。

这篇文章不仅给出了常见的面试题和答案，并且给出了这些知识点的利用场景、也给出了解决这些问题的思路，并且联合这些思路提供了要害代码。这些代码段都是能够间接 CV 到本地运行起来的，并且都写分明了正文，欢送大家动起手来操练起来，不要死记硬背八股文。

最初，整顿不易，原创更不易，你的点赞、留言、转发是对我最大的反对！

全网搜寻：王中阳 Go，取得更多面试题材料。

退出移动版