Go的简单问题问答

基础问题回答

1. Go 的主要特点是什么？

   • 简洁：语法简化，减少复杂性。
   • 并发：内置 Goroutine 和 Channel，支持轻量级并发。
   • 静态类型：强类型语言，编译时检查错误。
   • 跨平台：编译生成独立的二进制文件，无需外部依赖。

2. Go 的数据类型有哪些？

   • 基本类型：int, float64, bool, string。
   • 复合类型：array, slice, map, struct。
   • 指针：如 *int。
   • 接口：interface{} 表示通用类型。

3. 解释 Go 的 slice 和 array 的区别。

   • Array 是固定大小的，声明后无法改变：[5]int。
   • Slice 是动态的，可以扩展，底层是 Array 的引用：[]int。

4. Go 的零值是什么？

   • 数值类型为 0，布尔为 false，字符串为 ""，指针和接口为 nil。

5. 如何在 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
     }
     

6. Go 中的变量声明和初始化方式有哪些？

   • 使用 var：var x int = 10。
   • 使用短声明：x := 10。
   • 未初始化变量有零值。

---

中级问题回答

1. 什么是 Goroutine？它与线程有何不同？

   • Goroutine 是 Go 的用户级线程，轻量级，内存占用小（约 2KB），通过 Go 运行时调度。
   • 线程是操作系统管理的，启动代价高，且需要系统调用。

2. 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()
     

3. 如何防止 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)
     

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

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

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

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

   • defer 延迟执行，按 LIFO 顺序。

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

6. Go 中的通道（Channel）是什么？有什么类型？

   • 无缓冲通道：发送者和接收者需同步。
   • 缓冲通道：支持异步通信：make(chan int, 2)。

7. select 语句的作用是什么？

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

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

---

高级问题回答

1. Go 中的垃圾回收机制是怎样的？

   • Go 使用并发的标记-清除算法（Tri-color Mark & Sweep），避免暂停整个程序。

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

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

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

3. 如何优化 Go 中的高并发程序？

   • 控制 Goroutine 数量：使用 Worker Pool 模式。
   • 优化 Channel 的容量，减少锁竞争。

---

实战型问题回答

1. 设计一个简单的 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)
   }
   

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

   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
   }
   

3. 生产者消费者模式：

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

---