【Go语言学习系列28】并发编程（一）：goroutine基础

📚 原创系列： “Go语言学习系列”

🔄 转载说明： 本文最初发布于"Gopher部落"微信公众号，经原作者授权转载。

🔗 关注原创： 欢迎扫描文末二维码，关注"Gopher部落"微信公众号获取第一手Go技术文章。

📑 Go语言学习系列导航

本文是【Go语言学习系列】的第28篇，当前位于第三阶段（进阶篇）

28. 并发编程（一）：goroutine基础👈 当前位置
29. 并发编程（二）：channel基础
30. 并发编程（三）：select语句
31. 并发编程（四）：sync包
32. 并发编程（五）：并发模式
33. 并发编程（六）：原子操作与内存模型
34. 数据库编程（一）：SQL接口
35. 数据库编程（二）：ORM技术
36. Web开发（一）：路由与中间件
37. Web开发（二）：模板与静态资源
38. Web开发（三）：API开发
39. Web开发（四）：认证与授权
40. Web开发（五）：WebSocket
41. 微服务（一）：基础概念
42. 微服务（二）：gRPC入门
43. 日志与监控
44. 第三阶段项目实战：微服务聊天应用

📚 查看完整Go语言学习系列导航

📖 文章导读

在本文中，您将了解：

• goroutine的概念及其与传统线程的核心区别
• Go运行时如何管理和调度goroutine
• 如何正确创建和使用goroutine
• CSP并发模型的基本思想与应用
• 避免goroutine泄漏和竞态条件的最佳实践
• 在实际项目中应用goroutine的常见模式

无论您是并发编程新手还是有经验的开发者，本文都将帮助您掌握Go语言最具特色的并发特性，为编写高效可靠的并发程序奠定基础。

并发编程（一）：goroutine基础

并发编程是Go语言最具特色的功能之一，它使得我们能够轻松地编写高效的并发程序。Go语言通过goroutine和channel两大核心机制，为开发者提供了简单而强大的并发编程模型。本文将深入探讨goroutine的基础知识，帮助你掌握Go语言并发编程的基本技能。

一、goroutine概念与特性

goroutine是Go语言并发设计的核心，它是一种轻量级的用户态线程，由Go运行时（runtime）管理。

1.1 goroutine与线程的区别

goroutine与传统线程相比有诸多优势：

1. 极低的创建和切换成本

   • goroutine的初始栈大小仅有2KB（Go 1.18后为2KB，此前是8KB）
   • 而线程的栈通常是MB级别

2. 动态栈大小

   • goroutine的栈大小可以根据需要动态增长和收缩
   • 最大可达1GB（64位系统）

3. 高效的调度模型

   • Go运行时实现了M:N的调度模型
   • 多个goroutine（N）可以在少量系统线程（M）上运行
   • 避免了上下文切换的高成本

4. 与线程的数量对比

   • 系统可以轻松支持数十万甚至数百万的goroutine同时运行
   • 创建同等数量的线程会耗尽系统资源

1.2 goroutine的工作原理

Go运行时负责goroutine的创建、调度和销毁：

┌─────────────────────┐
│     Go 应用程序       │
│  ┌───────┬───────┐  │
│  │ goroutine    │  │
│  │ goroutine    │  │
│  │ ...          │  │
│  └───────┴───────┘  │
└──────────┬──────────┘
           │
┌──────────▼──────────┐
│     Go 运行时        │
│  ┌───────┬───────┐  │
│  │ 调度器 │ GC    │  │
│  └───────┴───────┘  │
└──────────┬──────────┘
           │
┌──────────▼──────────┐
│      操作系统        │
│  ┌───────┬───────┐  │
│  │ 线程   │ 内存   │  │
│  └───────┴───────┘  │
└─────────────────────┘

• GMP模型：Go调度器基于GMP模型工作
  • G: goroutine，用户级线程
  • M: machine，操作系统线程
  • P: processor，调度上下文，负责连接M和G

二、启动与调度

在Go中启动goroutine非常简单，只需使用go关键字即可。

2.1 创建goroutine

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    fmt.Println("Hello from goroutine!")
}

func main() {
    // 启动一个goroutine
    go sayHello()
    
    // 防止主goroutine退出太快
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Main function finished")
}

在这个例子中：

1. go sayHello() 启动了一个新的goroutine执行sayHello函数
2. 主函数不会等待goroutine完成，需要通过time.Sleep让主goroutine等待

2.2 传递参数

启动goroutine时可以传递参数：

func printValue(val int) {
    fmt.Printf("Value: %d\n", val)
}

func main() {
    for i := 0; i < 5; i++ {
        // 通过函数参数传值
        go printValue(i)
    }
    time.Sleep(100 * time.Millisecond)
}

闭包中的变量陷阱：

func main() {
    for i := 0; i < 5; i++ {
        // 错误方式：所有goroutine可能会打印相同的值
        go func() {
            fmt.Printf("Value: %d\n", i)
        }()
        
        // 正确方式：将变量作为参数传入
        go func(val int) {
            fmt.Printf("Value: %d\n", val)
        }(i)
    }
    time.Sleep(100 * time.Millisecond)
}

2.3 调度时机

Go运行时会在以下情况触发goroutine调度：

1. 系统调用：当goroutine执行系统调用时（如I/O操作）
2. 通道操作：在channel上的发送和接收操作可能导致阻塞
3. 垃圾回收：GC工作时可能触发调度
4. 显式调用：通过runtime.Gosched()主动让出CPU
5. 等待锁：当争用sync包中的互斥锁时
6. 函数调用：当函数调用太深且栈需要扩容时

示例 - 主动让出CPU：

package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func() {
        for i := 0; i < 3; i++ {
            fmt.Println("Goroutine:", i)
        }
    }()
    
    for i := 0; i < 3; i++ {
        // 让出CPU，给其他goroutine执行的机会
        runtime.Gosched()
        fmt.Println("Main:", i)
    }
}

三、并发模型

Go的并发哲学基于CSP（Communicating Sequential Processes，通信顺序进程）模型。

3.1 CSP原则

CSP模型的核心思想是：

“不要通过共享内存来通信，而要通过通信来共享内存”

这一原则鼓励通过显式的消息传递（channel）而非共享状态来协调并发执行，从而减少锁和同步原语的使用。

3.2 并发模式对比

3.3 基本并发模式示例

工作者池模式：

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    
    for job := range jobs {
        fmt.Printf("Worker %d started job %d\n", id, job)
        time.Sleep(time.Second) // 模拟工作时间
        fmt.Printf("Worker %d finished job %d\n", id, job)
        results <- job * 2 // 发送结果
    }
}

func main() {
    const numJobs = 5
    const numWorkers = 3
    
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)
    
    // 启动工作者
    var wg sync.WaitGroup
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }
    
    // 发送工作
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs) // 关闭通道表示没有更多工作
    
    // 等待所有工作完成
    wg.Wait()
    close(results)
    
    // 收集结果
    for result := range results {
        fmt.Println("Result:", result)
    }
}

四、常见陷阱与最佳实践

4.1 goroutine泄漏

goroutine泄漏是指创建的goroutine没有正确终止，导致资源无法释放。

常见原因：

1. 通道操作阻塞：在无缓冲通道上发送或接收，但没有对应的接收或发送操作
2. 永不退出的循环：包含无限循环的goroutine
3. 缺少取消机制：没有实现超时或取消功能

泄漏示例：

func leakyFunction() {
    ch := make(chan int) // 无缓冲通道
    
    go func() {
        val := 42
        ch <- val // 将永远阻塞，因为没有接收方
    }()
    
    // 没有从ch接收的代码
    // goroutine将永远卡在通道发送操作上
}

解决方法：

1. 使用context进行取消：

func nonLeakyFunction(ctx context.Context) {
    ch := make(chan int)
    
    go func() {
        val := 42
        select {
        case ch <- val:
            // 发送成功
        case <-ctx.Done():
            // 上下文被取消，goroutine可以退出
            return
        }
    }()
    
    // 使用时带超时
    select {
    case result := <-ch:
        fmt.Println("Got:", result)
    case <-ctx.Done():
        fmt.Println("Operation canceled")
    case <-time.After(1 * time.Second):
        fmt.Println("Timeout")
    }
}

4.2 竞态条件

竞态条件是指多个goroutine同时访问共享数据且至少有一个进行写操作时产生的情况。

检测方法：

使用Go内置的竞态检测器：

go test -race ./...
go run -race main.go

解决方法：

1. 使用互斥锁：

var (
    counter int
    mutex   sync.Mutex
)

func safeIncrement() {
    mutex.Lock()
    defer mutex.Unlock()
    counter++
}

2. 使用通道代替共享内存：

func counterService(ch chan int) {
    counter := 0
    for {
        counter += <-ch
    }
}

func main() {
    ch := make(chan int)
    go counterService(ch)
    
    // 安全地增加计数器
    ch <- 1
    ch <- 1
}

4.3 正确使用WaitGroup

使用sync.WaitGroup等待一组goroutine完成：

func process(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 确保在函数退出时调用Done
    
    // 处理逻辑
    fmt.Printf("Process %d done\n", id)
}

func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 5; i++ {
        wg.Add(1) // 在启动goroutine前增加计数
        go process(i, &wg)
    }
    
    wg.Wait() // 等待所有goroutine完成
    fmt.Println("All processes done")
}

常见错误：

• 忘记调用Done()
• 在goroutine内部而不是外部调用Add()
• Add()和Done()的调用次数不匹配

五、实际应用场景

5.1 并行处理多个请求

func processRequest(req Request) Result {
    // 处理单个请求的逻辑
    return Result{/*...*/}
}

func handleRequests(requests []Request) []Result {
    results := make([]Result, len(requests))
    var wg sync.WaitGroup
    
    for i, req := range requests {
        wg.Add(1)
        go func(i int, req Request) {
            defer wg.Done()
            results[i] = processRequest(req)
        }(i, req)
    }
    
    wg.Wait()
    return results
}

5.2 数据处理管道

func generator(nums []int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums {
            out <- n
        }
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in {
            out <- n * n
        }
    }()
    return out
}

func main() {
    // 创建数据处理管道
    nums := []int{2, 3, 4, 5}
    dataStream := generator(nums)
    squaredStream := square(dataStream)
    
    // 消费处理结果
    for result := range squaredStream {
        fmt.Println(result)
    }
}

👨‍💻 关于作者与Gopher部落

"Gopher部落"专注于Go语言技术分享，提供从入门到精通的完整学习路线。

🌟 为什么关注我们？

1. 系统化学习路径：本系列44篇文章循序渐进，带你完整掌握Go开发
2. 实战驱动教学：理论结合实践，每篇文章都有可操作的代码示例
3. 持续更新内容：定期分享最新Go生态技术动态与大厂实践经验
4. 专业技术社区：加入我们的技术交流群，与众多Go开发者共同成长

📱 关注方式

1. 微信公众号：搜索 “Gopher部落” 或 “GopherTribe”
2. CSDN专栏：点击页面右上角"关注"按钮

💡 读者福利

关注公众号回复 “Go并发” 即可获取：

• 完整Go并发编程示例代码
• Go并发模式实战指南PDF
• 高性能Go应用优化技巧

期待与您在Go语言的学习旅程中共同成长！