Golang 开发高频面试题

### Golang 常见面试题总结 Golang 是一种高效的编程语言，广泛应用于后端开发、分布式系统和微服务架构中。以下是常见的 Golang 面试题，涵盖基础概念、代码实现和设计模式等方面。 #### 1. 基础概念 - **Goroutine 和 Channel 的使用** Goroutine 是 Golang 的轻量级线程，Channel 是 Goroutine 之间的通信机制[^1]。例如，通过 Channel 实现生产者-消费者模式： ```go package main import ( "fmt" ) func producer(ch chan<- int) { for i := 0; i < 5; i++ { ch <- i } close(ch) } func consumer(ch <-chan int) { for v := range ch { fmt.Println(v) } } func main() { ch := make(chan int) go producer(ch) consumer(ch) } ``` - **垃圾回收（GC）机制** Go 的垃圾回收采用三色标记算法，存在 STW（Stop The World）阶段[^2]。STW 是指在某些特定时刻，所有用户级别的 Goroutine 都会被暂停以完成必要的 GC 操作。 - **GPM 调度模型** Golang 使用 GPM 调度模型（Goroutine, Processor, Machine），其中 M 表示操作系统线程，P 表示处理器，G 表示 Goroutine。调度器负责将 Goroutine 分配到 P 和 M 上运行[^2]。 #### 2. 代码实现 - **延迟队列的实现** 可以通过 `time.After` 或结合 Redis 实现延迟队列。以下是一个简单的基于 `time.After` 的延迟队列示例： ```go package main import ( "fmt" "sync" "time" ) type DelayQueue struct { tasks map[int]time.Time mu sync.Mutex } func NewDelayQueue() *DelayQueue { return &DelayQueue{tasks: make(map[int]time.Time)} } func (dq *DelayQueue) Add(id int, delay time.Duration) { dq.mu.Lock() defer dq.mu.Unlock() dq.tasks[id] = time.Now().Add(delay) } func (dq *DelayQueue) Process() { for { dq.mu.Lock() now := time.Now() for id, due := range dq.tasks { if due.Before(now) { fmt.Println("Processing task:", id) delete(dq.tasks, id) } } dq.mu.Unlock() time.Sleep(1 * time.Second) } } func main() { dq := NewDelayQueue() dq.Add(1, 5*time.Second) dq.Add(2, 10*time.Second) go dq.Process() time.Sleep(15 * time.Second) } ``` - **并发安全的数据结构** 使用 `sync.Mutex` 或 `sync.RWMutex` 实现并发安全的切片或 Map。例如： ```go package main import ( "fmt" "sync" ) type SafeMap struct { mu sync.RWMutex m map[string]int } func NewSafeMap() *SafeMap { return &SafeMap{m: make(map[string]int)} } func (sm *SafeMap) Set(key string, value int) { sm.mu.Lock() defer sm.mu.Unlock() sm.m[key] = value } func (sm *SafeMap) Get(key string) int { sm.mu.RLock() defer sm.mu.RUnlock() return sm.m[key] } func main() { sm := NewSafeMap() sm.Set("key1", 42) fmt.Println(sm.Get("key1")) } ``` #### 3. 设计模式 - **单例模式** 在 Golang 中可以通过函数闭包实现单例模式： ```go package main import "fmt" type Singleton struct{} var instance *Singleton var once sync.Once func GetInstance() *Singleton { once.Do(func() { instance = &Singleton{} }) return instance } func main() { s1 := GetInstance() s2 := GetInstance() fmt.Println(s1 == s2) // true } ``` - **工厂模式** 工厂模式用于创建对象而无需指定具体类： ```go package main import "fmt" type Product interface { Use() } type ConcreteProductA struct{} func (p *ConcreteProductA) Use() { fmt.Println("Using Product A") } type ConcreteProductB struct{} func (p *ConcreteProductB) Use() { fmt.Println("Using Product B") } func CreateProduct(name string) Product { switch name { case "A": return &ConcreteProductA{} case "B": return &ConcreteProductB{} default: return nil } } func main() { product := CreateProduct("A") product.Use() } ``` #### 4. 高频问题 - **什么是 CSP 并发模型？** CSP（Communicating Sequential Processes）是一种并发模型，强调通过消息传递而不是共享内存来实现并发[^2]。Go 的 Goroutine 和 Channel 是 CSP 模型的具体实现。 - **如何避免竞态条件？** 使用同步原语如 `sync.Mutex` 或 `sync.RWMutex`，或者通过 Channel 实现无锁的并发控制[^2]。 ---