---
tags: [go, golang, interview, code-questions]
create time: 2026-06-07 14:30
---

# 编程算法面试题 💻

## 概述

本文件涵盖 Go 并发编程场景下的 9 道代码实现题，涉及协程同步、通道协作、并发控制等实战场景。这些题目在面试中通常要求"现场手写代码"，考察对 Channel、Mutex、WaitGroup 的综合运用能力。

> [!tip] 💡 使用建议
> 每道题先自己思考解题思路，再对照答案学习。重点理解"为什么用这种方式"而非死记代码。

## 关联笔记

- [[hzh/GolangStar/Go面试题库/Channel面试题]] — Channel 原理
- [[hzh/GolangStar/Go面试题库/Sync面试题]] — Mutex/WaitGroup 原理
- [[hzh/GolangStar/Go面试题库/Context面试题]] — Context 超时控制

## 正文

### Q1：100 个协程顺序打印 1-1000 🟡中等

> [!question] ❓ 思考一下
> 100 个协程同时运行，如何让它们按 1-1000 的顺序依次打印？你会用什么机制来协调它们的执行顺序？

## 参考答案

**核心思路**：用 map 为每个协程分配独立的 channel，主循环按序发送信号到对应协程的 channel，通过阻塞保证顺序。

```go
func main() {
    s := make(chan struct{})                    // 控制打印顺序的信号
    m := make(map[int]chan int, 100)            // 每个协程的入口 channel

    for i := 1; i <= 100; i++ {
        m[i] = make(chan int)
        go func(id int) {
            for {
                num := <-m[id]                  // 等待属于自己的数字
                fmt.Println(num)
                s <- struct{}{}                 // 打印完成，通知主循环
            }
        }(i)
    }

    for i := 1; i <= 1000; i++ {
        id := i % 100
        if id == 0 { id = 100 }
        m[id] <- i                              // 发送给对应协程
        <-s                                     // 阻塞等待该协程打印完毕
    }
}
```

> [!note] 📝 解析思路
> - **map + channel 组合**：每个协程独占一个 channel，主循环精确投递
> - **信号量 s**：每次只发一个数，收到打印完成的信号才发下一个，保证严格顺序
> - **面试官可能会追问**："如果不用 map 怎么做？"→ 可以用 100 个独立声明的 channel 或用 `sync.Mutex` 保护共享输出

---

### Q2：三个 goroutine 交替打印 abc 10 次 🟡中等

## 参考答案

**核心思路**：三个 channel 串联成环形，a -> b -> c -> a。

```go
func main() {
    ch1 := make(chan struct{}) // a → b
    ch2 := make(chan struct{}) // b → c
    ch3 := make(chan struct{}) // c → a
    var wg sync.WaitGroup
    wg.Add(3)

    // 打印 a
    go func() {
        defer wg.Done()
        for i := 0; i < 10; i++ {
            <-ch1
            fmt.Print("a")
            ch2 <- struct{}{}
        }
        <-ch1 // 消费最后一次信号
    }()

    // 打印 b
    go func() {
        defer wg.Done()
        for i := 0; i < 10; i++ {
            <-ch2
            fmt.Print("b")
            ch3 <- struct{}{}
        }
    }()

    // 打印 c
    go func() {
        defer wg.Done()
        for i := 0; i < 10; i++ {
            <-ch3
            fmt.Print("c")
            ch1 <- struct{}{}
        }
    }()

    ch1 <- struct{}{} // 启动信号
    wg.Wait()
    close(ch1)
    close(ch2)
    close(ch3)
    fmt.Println("end")
}
```

> [!warning] ⚠️ 高频陷阱
> 第 10 次打印 c 后会给 ch1 发信号，但 a 的循环已经结束了。需要额外消费一次 ch1 防止阻塞。

> [!tip] 💡 面试技巧
> 回答时可以画图展示三个 channel 的环形关系，然后说明"每次只有收到信号的 goroutine 才能执行，执行完给下一个发信号"。

---

### Q3：不超过 10 个 goroutine 不重复打印 slice 中的 100 个元素 🟡中等

## 参考答案

**方案一**：有缓冲 channel 控制并发度（无序）

```go
ch := make(chan struct{}, 10) // 容量 10 = 最大并发数
for i := 0; i < 100; i++ {
    wg.Add(1)
    ch <- struct{}{}           // 写满 10 个后阻塞
    go func(idx int) {
        defer wg.Done()
        fmt.Printf("%d\n", ss[idx])
        <-ch                   // 打印完释放一个槽位
    }(i)
}
```

**方案二**：固定 10 个 goroutine 顺序打印

```go
hashMap := make(map[int]chan int)  // 10 个 channel 对应 10 个 goroutine
sort := make(chan struct{})         // 控制顺序

for i := 0; i < 10; i++ {
    hashMap[i] = make(chan int)
    go func(idx int) {
        for val := range hashMap[idx] {
            fmt.Printf("go %d: %d\n", idx, val)
            sort <- struct{}{}      // 打印完通知
        }
    }(i)
}

for _, v := range ss {
    id := v % 10
    hashMap[id] <- v
    <-sort                           // 等当前打印完再发下一个
}
```

> [!info] 🔗 延伸阅读
> - 方案一适合不需要顺序的场景（吞吐量优先）
> - 方案二适合需要顺序的场景（可控性优先）

---

### Q4：两个协程交替打印奇偶数 🟢简单

## 参考答案

```go
chan1 := make(chan struct{})

// 偶数协程
go func() {
    for i := 0; i < 10; i++ {
        chan1 <- struct{}{}           // 发出信号
        if i%2 == 0 {
            fmt.Println("偶数:", i)
        }
    }
}()

// 奇数协程
go func() {
    for i := 0; i < 10; i++ {
        <-chan1                        // 等待信号
        if i%2 == 1 {
            fmt.Println("奇数:", i)
        }
    }
}()
```

---

### Q5：用单个 channel 实现 0,1 交替打印 🟢简单

## 参考答案

```go
msg := make(chan struct{})

go func() {
    for {
        <-msg                         // 接收信号
        fmt.Println("0")
        msg <- struct{}{}             // 回传信号
    }
}()

go func() {
    for {
        <-msg                         // 接收信号
        fmt.Println("1")
        msg <- struct{}{}             // 回传信号
    }
}()

msg <- struct{}{}                     // 初始信号
```

> [!tip] 💡 面试技巧
> "用一个 channel 作为信号灯，0 和 1 各持一半——谁拿到灯谁就打印，打印完把灯放回 channel。"

---

### Q6：sync.Cond 实现多生产者多消费者 🟡中等

## 参考答案

```go
var cond sync.Cond
cond.L = new(sync.Mutex)
msgCh := make(chan int, 5)

// 生产者：缓冲区满时等待
producer := func(ctx context.Context, out chan<- int, idx int) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            cond.Broadcast()
            return
        default:
            cond.L.Lock()
            for len(msgCh) == 5 {
                cond.Wait()  // 缓冲区满，等待
            }
            out <- rand.Intn(500)
            cond.Signal()     // 唤醒一个消费者
            cond.L.Unlock()
        }
    }
}

// 消费者：缓冲区空时等待
consumer := func(ctx context.Context, in <-chan int, idx int) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            for len(msgCh) > 0 { /* 继续消费 */ }
            return
        default:
            cond.L.Lock()
            for len(msgCh) == 0 {
                cond.Wait()   // 缓冲区空，等待
            }
            num := <-in
            cond.Signal()     // 唤醒一个生产者
            cond.L.Unlock()
        }
    }
}
```

> [!note] 📝 解析思路
> `sync.Cond` 的核心是：**Lock + Wait/Signal/Broadcast**。Wait 会释放锁并挂起 goroutine，Signal 唤醒一个等待者，Broadcast 唤醒全部。适合"条件满足才执行"的场景。

---

### Q7：1000 个并发控制 + 1 秒超时 🟡中等

## 参考答案

```go
tasks := make(chan int, 1000)
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel()
var wg sync.WaitGroup

for i := 0; i < 1000; i++ {
    wg.Add(1)
    tasks <- i
    go func(id int) {
        defer wg.Done()
        select {
        case <-ctx.Done():
            return              // 超时退出
        default:
            fmt.Printf("goroutine %d\n", id)
        }
    }(i)
}

<-ctx.Done()
fmt.Println("exec done")
close(tasks)
wg.Wait()
```

> [!warning] ⚠️ 高频陷阱
> 这段代码的缺陷是 1000 个 goroutine 几乎同时启动，1 秒内可能来不及全部执行完。实际场景中应限制并发数量（如用 semaphore channel）。

> [!tip] 💡 面试技巧
> 如果面试官指出问题，可以回答："可以用有缓冲 channel 做信号量控制并发数：`sem := make(chan struct{}, 10)`，获取/释放 sem 来控制最多 10 个并发。"

---

### Q8：两个 Goroutine 交替打印字母与数字 a1b2c3 🟡中等

## 参考答案

```go
numCh := make(chan struct{}) // 通知打印数字
strCh := make(chan struct{}) // 通知打印字母
var wg sync.WaitGroup
wg.Add(2)

// 打印字符 a-z
go func() {
    defer wg.Done()
    for i := 'a'; i <= 'z'; i++ {
        fmt.Print(string(i))
        numCh <- struct{}{}   // 通知打印数字
        <-strCh               // 等待对方完成
    }
}()

// 打印数字 1-26
go func() {
    defer wg.Done()
    for i := 1; i <= 26; i++ {
        <-numCh               // 等待对方完成
        fmt.Print(i)
        strCh <- struct{}{}   // 通知打印字母
    }
}()

wg.Wait()
```

---

### Q9：限制 10 个 goroutine 执行，执行完一个放一个新进来 🟢简单

## 参考答案

```go
ch := make(chan struct{}, 10) // 容量 10 = 并发上限
var wg sync.WaitGroup

for i := 0; i < 20; i++ {
    wg.Add(1)
    ch <- struct{}{}           // 写满 10 个后自动阻塞
    go func(id int) {
        defer wg.Done()
        fmt.Printf("id: %d\n", id)
        <-ch                   // 执行完释放一个槽位
    }(i)
}
wg.Wait()
```

> [!tip] 💡 面试技巧
> 这是最经典的**并发控制模式**——用有缓冲 channel 做信号量（Semaphore）。面试中如果只写出这个，说明掌握了基础；如果能补充"用 context 加超时"或"用 errgroup 处理错误"，则是加分项。

## 关联笔记

- [[hzh/GolangStar/Go面试题库/Channel面试题]]
- [[hzh/GolangStar/Go面试题库/Sync面试题]]
- [[hzh/GolangStar/Go面试题库/Context面试题]]