Go的简单问题问答

基础问题回答

Go 的主要特点是什么？
- 简洁：语法简化，减少复杂性。
- 并发：内置 Goroutine 和 Channel，支持轻量级并发。
- 静态类型：强类型语言，编译时检查错误。
- 跨平台：编译生成独立的二进制文件，无需外部依赖。
Go 的数据类型有哪些？
- 基本类型：int, float64, bool, string。
- 复合类型：array, slice, map, struct。
- 指针：如 *int。
- 接口：interface{} 表示通用类型。
解释 Go 的 slice 和 array 的区别。
- Array 是固定大小的，声明后无法改变：[5]int。
- Slice 是动态的，可以扩展，底层是 Array 的引用：[]int。
Go 的零值是什么？
- 数值类型为 0，布尔为 false，字符串为 ""，指针和接口为 nil。

如何在 Go 中实现错误处理？

使用 error 接口，结合 errors.New 和 fmt.Errorf 生成错误。

例如：

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

Go 中的变量声明和初始化方式有哪些？
- 使用 var：var x int = 10。
- 使用短声明：x := 10。
- 未初始化变量有零值。

中级问题回答

什么是 Goroutine？它与线程有何不同？
- Goroutine 是 Go 的用户级线程，轻量级，内存占用小（约 2KB），通过 Go 运行时调度。
- 线程是操作系统管理的，启动代价高，且需要系统调用。

Go 的 sync.WaitGroup 是什么？如何使用？

sync.WaitGroup 用于等待一组 Goroutine 完成：

var wg sync.WaitGroup
wg.Add(2)
go func() {
    defer wg.Done()
    fmt.Println("Task 1 completed")
}()
go func() {
    defer wg.Done()
    fmt.Println("Task 2 completed")
}()
wg.Wait()

如何防止 Goroutine 泄漏？

使用 context 取消操作：

ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go func(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            return
        default:
            fmt.Println("Running")
        }
    }
}(ctx)

Go 的接口是什么？如何使用？

接口是方法的集合，用于动态多态。

type Speaker interface {
    Speak() string
}
type Dog struct{}
func (d Dog) Speak() string { return "Woof!" }

什么是 defer？它的调用顺序是什么？

defer 延迟执行，按 LIFO 顺序。

func example() {
    defer fmt.Println("First")
    defer fmt.Println("Second")
    fmt.Println("Now")
}

Go 中的通道（Channel）是什么？有什么类型？
- 无缓冲通道：发送者和接收者需同步。
- 缓冲通道：支持异步通信：make(chan int, 2)。

select 语句的作用是什么？

用于监听多个通道的操作：

select {
case msg := <-ch1:
    fmt.Println("Received:", msg)
case ch2 <- "Hi":
    fmt.Println("Sent")
default:
    fmt.Println("No activity")
}

高级问题回答

Go 中的垃圾回收机制是怎样的？
- Go 使用并发的标记-清除算法（Tri-color Mark & Sweep），避免暂停整个程序。

解释 context 包的使用场景及实现原理。

用于传递超时、取消信号：

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

如何优化 Go 中的高并发程序？
- 控制 Goroutine 数量：使用 Worker Pool 模式。
- 优化 Channel 的容量，减少锁竞争。

实战型问题回答

设计一个简单的 Web 服务器：

package main
import (
    "fmt"
    "net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}
func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

实现一个并发安全的计数器：

type Counter struct {
    mu    sync.Mutex
    count int
}
func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}
func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

生产者消费者模式：

ch := make(chan int, 10)
go func() {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)
}()
for val := range ch {
    fmt.Println(val)
}