Golang协程怎么用 轻量级线程创建教程

Goroutine是Go的轻量级并发单元，通过go关键字启动，由Go运行时调度，相比操作系统线程更高效，具备小栈、低开销、高并发优势，配合WaitGroup、channel、context等机制可实现安全的并发控制与资源管理。

Golang中的goroutine，说白了，就是Go语言提供的一种轻量级并发执行单元。你想让一个函数在后台跑，不阻塞当前主流程，那就在函数调用前加个go关键字，它就能在一个独立的、由Go运行时管理的“轻量级线程”里跑起来了。这比操作系统线程的开销小得多，启动速度飞快，能轻松创建成千上万个，是Go实现高并发的秘密武器。

解决方案

使用goroutine其实非常直接，核心就是那个go关键字。

当你有一个函数，比如myFunc()，你想让它异步执行，就这么写：

go myFunc()

如果你的函数需要参数，也一样：

func greet(name string) {
    fmt.Println("Hello,", name)
}

go greet("World")

匿名函数也可以直接作为goroutine执行：

go func(msg string) {
    fmt.Println(msg)
}("你好，goroutine！")

需要注意的是，当主goroutine（也就是main函数）执行完毕并退出时，所有由它启动的子goroutine都会被强制终止，不管它们是否完成任务。这常常是新手遇到的第一个“坑”。为了让主goroutine等待其他goroutine完成，我们通常会用到sync.WaitGroup。

一个基本的使用模式是这样的：

package main

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

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // goroutine完成后，通知WaitGroup计数减一
    fmt.Printf("Worker %d 开始工作...\n", id)
    time.Sleep(time.Second * 1) // 模拟耗时操作
    fmt.Printf("Worker %d 完成工作。\n", id)
}

func main() {
    var wg sync.WaitGroup // 声明一个WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1) // 每启动一个goroutine，计数加一
        go worker(i, &wg)
    }

    wg.Wait() // 等待所有goroutine完成
    fmt.Println("所有worker都完成了。主程序退出。")
}

这段代码里，wg.Add(1)在启动每个goroutine前告诉WaitGroup我们要等一个任务。defer wg.Done()确保每个goroutine完成后都会通知WaitGroup它完成了。最后，wg.Wait()会阻塞主goroutine，直到WaitGroup的计数器归零。

Goroutine与传统线程有何本质区别，为什么Go选择这种设计？

这真是个好问题，也是理解Go并发模型关键中的关键。我个人觉得，如果你不明白这个，那你就没真正理解Go的并发。

本质区别：

1. 管理层面不同：

   • 传统线程（操作系统线程）： 它们是由操作系统内核来创建和调度的。每次创建、销毁、切换线程，都需要陷入内核态，开销是比较大的。它们是操作系统调度的基本单位。
   • Goroutine： 它们是Go运行时（runtime）在用户空间进行管理和调度的。Go运行时会将大量的goroutine多路复用到少量（通常是CPU核心数）的操作系统线程上。这种M:N的映射关系（M个goroutine对应N个OS线程）让Go可以自己决定什么时候切换goroutine，而不需要每次都找操作系统。

2. 栈空间：

   • 传统线程： 通常会预分配一个较大的固定栈空间（比如Linux上默认8MB），即使你只用了一点点。
   • Goroutine： 它们启动时栈空间非常小（通常只有几KB，比如2KB），而且可以根据需要动态地增长和收缩。这极大地节省了内存，使得你可以轻松创建成千上万个goroutine而不会耗尽内存。

3. 上下文切换开销：

   • 传统线程： 切换线程涉及保存/恢复CPU寄存器、程序计数器等，并且需要操作系统的参与，开销相对较大。
   • Goroutine： 切换goroutine是Go运行时在用户空间完成的，不涉及内核态切换，开销极低。

4. 调度方式：

   • 传统线程： 由操作系统的调度器进行抢占式调度。
   • Goroutine： Go运行时有自己的调度器（GPM模型），它会在函数调用、通道操作、锁操作等时机进行协作式调度，也会在Go 1.14之后进行基于抢占的调度。这让Go对并发的控制力更强，也更高效。

Go选择这种设计的原因：

说实话，Go语言设计之初就瞄准了网络服务和高并发场景。传统的线程模型在处理海量并发连接时，会面临“C10k问题”——即单台服务器难以同时处理1万个并发连接。创建太多线程会导致内存爆炸、上下文切换开销过大，最终系统崩溃。

Go的goroutine设计完美规避了这些问题：

• 极高的并发能力： 轻量级和动态栈使得启动数百万个并发任务成为可能，而不会耗尽资源。
• 简化并发编程： 开发者无需关心底层线程的创建和管理，只需要用go关键字启动任务，然后通过通道（channels）进行通信，这比传统的共享内存加锁模型要简单和安全得多。Go提倡“不要通过共享内存来通信，而应该通过通信来共享内存”的CSP（Communicating Sequential Processes）并发模型。
• 性能优异： 更低的上下文切换开销和高效的调度，使得Go在并发密集型任务上表现出色。

这玩意儿，我个人觉得是Go语言最亮眼的设计之一，它让并发编程从一个令人头疼的问题，变成了一个相当自然且高效的解决方案。

在实际项目中，如何有效管理大量Goroutine以避免资源耗尽或逻辑混乱？

管理大量goroutine，不仅仅是启动它们那么简单，更重要的是确保它们能按预期执行、适时退出，并且不会耗尽系统资源。这需要一些策略和工具。

1. 使用sync.WaitGroup协调Goroutine生命周期： 前面已经提到了，这是最基础也最常用的方式，用于等待一组goroutine完成。在处理批处理任务、并行计算等场景下非常有效。

   // 示例见上文解决方案部分

2. 利用通道（Channels）进行通信和协调： 通道是Go语言中goroutine之间通信的主要方式。它们不仅可以传递数据，还可以用于：

   • 任务分发： 主goroutine将任务发送到通道，多个worker goroutine从通道接收任务并处理。
   • 结果收集： worker goroutine将处理结果发送到另一个通道，主goroutine从该通道收集结果。
   • 限流/背压： 使用带缓冲的通道可以限制同时进行的任务数量，防止系统过载。比如，创建一个容量为N的通道，每当要启动一个goroutine时，先向通道发送一个空结构体，goroutine结束后再从通道接收一个。这样通道满的时候，新的goroutine启动就会阻塞。

   // 示例：使用带缓冲通道实现并发限制
   func main() {
       maxConcurrency := 5 // 最多同时运行5个goroutine
       guard := make(chan struct{}, maxConcurrency)
       var wg sync.WaitGroup
   
       for i := 0; i < 20; i++ {
           guard <- struct{}{} // 尝试发送，如果通道已满则阻塞
           wg.Add(1)
           go func(id int) {
               defer wg.Done()
               defer func() { <-guard }() // goroutine结束后从通道接收，释放一个槽位
               fmt.Printf("处理任务 %d...\n", id)
               time.Sleep(time.Millisecond * 200) // 模拟耗时
               fmt.Printf("任务 %d 完成。\n", id)
           }(i)
       }
       wg.Wait()
       fmt.Println("所有任务处理完毕。")
   }

3. 使用context包进行取消和超时控制： 对于那些可能长时间运行、或者需要外部信号来终止的goroutine，context包是不可或缺的。它允许你构建一个可传递的上下文树，通过Done()通道通知子goroutine取消操作，或者通过Err()方法检查取消原因。这对于优雅地关闭服务、处理请求超时等场景非常关键。

   func longRunningTask(ctx context.Context, id int) {
       for {
           select {
           case <-ctx.Done(): // 接收到取消信号
               fmt.Printf("任务 %d 被取消：%v\n", id, ctx.Err())
               return
           default:
               // 模拟工作
               fmt.Printf("任务 %d 正在进行...\n", id)
               time.Sleep(time.Millisecond * 300)
           }
       }
   }
   
   func main() {
       ctx, cancel := context.WithCancel(context.Background())
       go longRunningTask(ctx, 1)
   
       time.Sleep(time.Second * 1)
       cancel() // 发送取消信号
       time.Sleep(time.Millisecond * 500) // 等待goroutine退出
       fmt.Println("主程序退出。")
   }

4. 错误处理和日志记录： Goroutine内部的panic不会导致整个程序崩溃（除非是主goroutine），但如果不处理，会导致该goroutine悄无声息地退出，且可能留下未释放的资源。在goroutine内部使用defer和recover来捕获panic，并将错误通过通道报告给主goroutine或记录日志，是良好的实践。

5. 资源池化： 对于数据库连接、网络连接等有限资源，使用连接池来复用资源，而不是为每个goroutine都创建新的连接。这能有效避免资源耗尽。

这些策略结合起来，能让你在Go项目中更好地驾驭并发，让系统既高效又稳定。

Goroutine使用中常见的陷阱有哪些，以及如何规避？

虽然goroutine用起来很爽，但它也有些“脾气”，一不小心就可能掉进坑里。作为过来人，我总结了几个最常见的：

1. 主Goroutine过早退出： 这是最基础也最容易犯的错误。前面已经提过，如果main函数执行完了，所有子goroutine都会被Go运行时强制终止，不管它们是否完成任务。

   • 规避方法： 使用sync.WaitGroup来等待所有子goroutine完成。或者，如果是一个长期运行的服务，main函数通常会阻塞在一个无限循环、一个通道接收，或者一个HTTP服务器的ListenAndServe调用上。

2. 循环变量捕获问题（Closure Trap）： 当你在循环中启动goroutine，并且goroutine内部引用了循环变量时，很容易出问题。这是因为goroutine可能会在循环迭代结束后才真正开始执行，此时它们引用的循环变量已经变成了循环的最终值。

   // 陷阱示例：
   func main() {
       var wg sync.WaitGroup
       for i := 0; i < 5; i++ {
           wg.Add(1)
           go func() {
               defer wg.Done()
               fmt.Println(i) // 这里的i是外部循环变量的引用
           }()
       }
       wg.Wait()
   }
   // 运行结果很可能是：
   // 5
   // 5
   // 5
   // 5
   // 5

   • 规避方法： 在goroutine内部将循环变量作为参数传递，或者在循环内部创建一个新的局部变量来捕获当前迭代的值。

   // 规避方法1：将变量作为参数传递
   func main() {
       var wg sync.WaitGroup
       for i := 0; i < 5; i++ {
           wg.Add(1)
           go func(val int) { // 将i作为参数val传递
               defer wg.Done()
               fmt.Println(val)
           }(i) // 立即传递当前i的值
       }
       wg.Wait()
   }
   
   // 规避方法2：在循环内部创建新的局部变量
   func main() {
       var wg sync.WaitGroup
       for i := 0; i < 5; i++ {
           j := i // 创建一个新的局部变量j，捕获当前i的值
           wg.Add(1)
           go func() {
               defer wg.Done()
               fmt.Println(j)
           }()
       }
       wg.Wait()
   }
   // 运行结果通常是：
   // 0
   // 1
   // 2
   // 3
   // 4 (顺序不确定，但值是正确的)

3. 竞态条件（Race Conditions）： 多个goroutine同时访问和修改共享数据，但没有进行适当的同步控制，导致数据不一致或程序崩溃。这是并发编程中最经典的问题。

   • 规避方法：
     • 使用sync.Mutex或sync.RWMutex： 对共享资源的访问进行加锁保护。Mutex是互斥锁，RWMutex是读写锁（读不互斥，写互斥）。
     • 使用atomic包： 对于简单的原子操作（如增减计数器），使用sync/atomic包效率更高。
     • 通过通道（Channels）进行通信： 这是Go推荐的模式，即“不要通过共享内存来通信，而应该通过通信来共享内存”。让一个goroutine拥有数据的所有权，其他goroutine通过通道发送请求或接收数据。这通常能从根本上避免竞态条件。

4. Goroutine泄露（Goroutine Leaks）： Goroutine启动后，由于某种原因（比如通道发送方退出，但接收方还在等待；或者没有正确处理context.Done()信号），永远无法退出，持续占用内存和CPU资源。

   • 规避方法：
     • 确保所有通道操作都能完成： 如果一个goroutine在等待从一个通道接收数据，但没有发送方了，它就会一直阻塞。确保通道有发送方，或者使用select语句结合default或context.Done()来避免无限等待。
     • 使用context进行取消： 对于需要长时间运行的goroutine，传入context并定期检查ctx.Done()，以便在外部发出取消信号时优雅退出。
     • 避免无限循环： 除非是主goroutine或者明确设计为守护进程的goroutine，否则要确保循环有退出条件。

5. 死锁（Deadlocks）： 两个或多个goroutine互相等待对方释放资源或发送消息，导致所有涉及的goroutine都无限期阻塞。最常见的是通道操作，例如：

   • 一个goroutine向一个无缓冲通道发送数据，但没有其他goroutine从该通道接收数据。
   • 多个goroutine相互等待对方发送或接收数据。
   • 不当的锁顺序导致循环等待。
   • 规避方法：
     • 理解通道行为： 无缓冲通道需要发送和接收同时准备好。带缓冲通道只有在缓冲区满或空时才会阻塞。
     • 避免循环依赖： 仔细设计goroutine之间的通信和资源获取顺序。
     • 使用go tool trace和pprof： 这些工具可以帮助你分析Go程序的运行时行为，包括goroutine的阻塞情况，从而定位死锁。

这些坑，都是我自己在实践中踩过，或者看到别人踩过的。多加注意，就能让你的Go并发程序跑得又快又稳。