go 并发 - Goroutine和 Channel 的使用方法和技巧

文章摘要

这篇文章详细介绍了Go语言中的并发编程概念及其实现方法。内容包括Go语言的goroutine、channel的基本定义和使用方法。文章通过实例代码展示了如何启动和管理goroutine，如何使用channel在goroutine之间进行通信，以及select语句的使用。还讨论了并发编程中的常见问题和解决方案，如数据竞争和同步。整体内容适合初学者和有一定编程基础的用户参考学习。

Go语言的并发模型基于CSP（Communicating Sequential Processes）理论，这是一种并发编程范式，它强调通过通信来共享内存，而不是通过共享内存来通信。Go语言通过 goroutines 和 channels 来实现这一模型。

这句话主要强调了在多线程编程或者多进程编程中并发任务之间的通信方式。
传统的多线程编程方式中，线程之间通常通过共享内存的方式来交换数据或者同步状态。但这种方式容易导致竞态条件、死锁等问题，使得程序难以设计和维护。
而这句话提倡的是一种不同的并发编程范式，即通过数据的发送和接收来实现对共享数据的访问，而非直接访问共享内存。这种方式下，不同任务之间通过消息传递、事件、管道等来进行通信，而不是直接使用共享内存区。因此，实现通信的时候，可以有效避免并发问题。

特点

简洁性：Go 语言通过 goroutine 和 channel 两个核心概念实现了 CSP 模型，使得并发编程变得简单直观。开发者只需关注业务逻辑，而无需关心复杂的线程同步和锁机制。
轻量级：goroutine 是轻量级的用户态线程，与传统的操作系统线程相比，创建和销毁的开销非常小。这使得在 Go 语言中可以轻松地创建数十万甚至数百万个 goroutine 来处理并发任务。
高效性：Go 语言的调度器采用工作窃取算法，能够在用户态完成 goroutine 的调度，避免了频繁的系统调用，降低了上下文切换的开销。此外，Go 语言还提供了高效的网络轮询器，支持非阻塞 I/O操作，进一步提高了并发性能。
通信方式：channel 作为 Go 语言中用于在 goroutine 之间进行通信的管道，提供了一种同步机制，可以安全地在 goroutine 之间传递数据。这种方式遵循 CSP 理论，通过通信来共享内存，而不是通过共享内存来通信，有助于降低死锁的风险。
错误处理：Go 语言鼓励使用明确的错误返回值而不是异常，这在并发编程中尤其有用，因为它避免了复杂的异常处理逻辑，使得错误处理更加清晰和可维护。
可扩展性：Go 语言的并发模型具有良好的可扩展性，可以轻松地应对不同规模的并发需求。通过合理地控制并发数量和使用缓冲 channel，可以实现高效的并发处理。

与线程的区别

线程是操作系统调度的基本单位，每个线程都有独立的执行上下文和栈。线程之间的切换需要操作系统的介入。线程是传统的并发模型，适合需要系统级并发能力的任务。然而，线程的创建和调度开销较大，不适合高并发场景。

Go语言中的协程（Goroutine）和线程（Thread）在定义、调度方式、资源消耗、执行效率和适用场景上有显著区别。协程是轻量级的用户态线程，由Go运行时管理，具有更低的创建和调度开销，适合高并发场景。线程是操作系统管理的内核态线程，适合需要系统级并发能力的任务。

goroutines

协程（Goroutine）是 Go 语言中的轻量级线程，由 Go 运行时管理。协程具有自己的栈空间，但它们共享同一个线程的地址空间。协程的创建和销毁开销较小，可以高效地进行大规模并发处理。协程的设计使得它们在并发编程中非常高效，尤其是在需要大量并发执行任务时。协程的轻量级特性使得它们在资源占用和调度开销上具有优势。

生命周期

Goroutine 的生命周期可以分为以下几个阶段：

创建：通过 go 关键字启动一个新的 Goroutine。
运行：Goroutine 开始执行其函数体。
阻塞：Goroutine 可能会因为等待某些条件（如通道操作、锁等）而阻塞。
完成：Goroutine 执行完毕，生命周期结束。

生命周期管理

在实际应用中，管理 Goroutine 的生命周期是非常重要的。以下是一些常见的管理方法：

使用通道进行通信和同步：
- 通道可以用于在 Goroutine 之间传递数据和信号，从而协调它们的执行。
使用 sync.WaitGroup 等同步原语：
- sync.WaitGroup 可以用于等待一组 Goroutine 完成。
- sync.Mutex 和 sync.RWMutex 可以用于保护共享资源。
使用上下文（context）取消 Goroutine：
- context 包提供了上下文管理功能，可以用于取消 Goroutine。

上下文 context

context 是 Go 语言标准库中的一个包，它提供了一种机制，用于跟踪和控制多个并发操作的生命周期。context 的设计目的是为了简化对并发操作的管理，特别是在需要处理超时、取消信号、请求范围值等情况时。

context 的核心是 context.Context 接口，它定义了几个关键的方法：

Deadline() (deadline time.Time, ok bool): 返回context是否设置了截止时间，如果设置了，还会返回这个截止时间。
Done() <-chan struct{}: 返回一个通道，这个通道会在context被取消或超时时关闭。
Err() error: 返回context被取消时的错误。
Value(key interface{}) interface{}: 从context中获取键对应的值。

context 包提供了几个用于创建和管理 Context 的函数：

context.Background(): 返回一个空的 Context，这个 Context 一般用于整个请求链的最顶端。
context.TODO(): 当不确定应该使用哪个 Context 或还没有可用的 Context 时使用。
context.WithCancel(parent Context): 创建一个新的 Context 和一个取消函数。当取消函数被调用时，新的 Context 的 Done 通道会被关闭。
context.WithDeadline(parent Context, deadline time.Time): 创建一个有截止时间的 Context。当到达截止时间时，Done 通道会被关闭。
context.WithTimeout(parent Context, timeout time.Duration): 创建一个有超时时间的 Context，超时后 Done 通道会被关闭。
context.WithValue(parent Context, key, value interface{}): 创建一个新的 Context，并关联一对键值。

使用场景

超时控制：当你有一个可能需要长时间运行的操作时，你可以使用 context.WithTimeout 来设置一个超时时间。如果操作在超时时间内未完成，context 可以用来取消该操作。
取消操作：在有多个并发操作时，如果其中一个操作失败，你可能需要取消所有其他操作。context 的取消机制可以确保所有相关的操作都能收到取消信号。
传递请求范围的值：在处理HTTP请求时，你可能需要在不同的处理函数之间传递数据，例如请求ID或用户认证信息。context.WithValue 可以用来在请求处理的上下文中传递这些值。
控制并发操作：context 可以用来同步多个goroutine，确保它们按照预期的顺序执行，或者在某个操作完成后触发其他操作。
资源清理：使用 context 可以确保打开的资源（如数据库连接、文件句柄等）在不再需要时被正确关闭。

示例：使用上下文取消 Goroutine

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Worker: canceled")
            return
        default:
            fmt.Println("Worker: working")
            time.Sleep(500 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    go worker(ctx)

    time.Sleep(2 * time.Second)
    cancel() // 取消 Goroutine
    time.Sleep(1 * time.Second)
}

不足

调试困难：并发编程往往难以调试，特别是在出现竞态条件、死锁或资源泄漏时，定位问题可能非常困难。
死锁风险：如果不正确地同步goroutine，可能会导致死锁，即一组goroutine互相等待对方释放资源，从而导致程序挂起。
竞态条件：当多个goroutine并发访问共享资源时，可能会发生竞态条件，导致数据不一致或其他不可预测的行为。
阻塞操作：当一个goroutine执行阻塞操作（如I/O等待）时，它可能会占用一个操作系统线程，这可能导致其他goroutine无法得到足够的CPU时间来执行。

Channels

通信机制：Channels 是 Go 语言中用于在 goroutines 之间进行通信的管道。它们提供了一种同步机制，可以安全地在 goroutines 之间传递数据。
类型安全：Channels 是类型安全的，这意味着你只能发送和接收特定类型的数据。
阻塞操作：当一个 goroutine 尝试向一个满的 channel 发送数据或从一个空的 channel 接收数据时，它会阻塞，直到操作可以完成。

语法

# 创建 channel
ch := make(chan int)

# 向 channel 发送数据
ch <- 42 // 将整数 42 发送到 channel ch

# 从 channel 接收数据
value := <-ch // 从 channel ch 接收数据并将其赋值给变量 value

# 关闭 channel
close(ch)

# 使用 range 遍历 channel
# 使用 range 关键字可以方便地遍历 channel 中的所有数据。当 channel 被关闭且所有数据已被接收时，循环将自动结束。例如：
for value := range ch {
    fmt.Println(value)
}

# 单向 channel
// 发送数据的单向 channel
sendCh := make(chan<- int)
// 接收数据的单向 channel
receiveCh := make(<-chan int)

# 缓冲 channel
ch := make(chan int, 5) // 创建一个带缓冲区大小为 5 的整数类型 channel

# 选择语句
# 使用 select 语句可以在多个 channel 操作之间进行选择。当多个操作都可以执行时，Go 语言会随机选择一个。例如：
select {
case ch1 <- value:
    fmt.Println("发送到 ch1 成功")
case value = <-ch2:
    fmt.Println("从 ch2 接收数据成功")
default:
    fmt.Println("没有可执行的操作")
}

单向 channel（如 chan<- int 和 <-chan int）和双向 channel（如 chan int），在性能上没有显著差异，主要区别在于它们的用法和可读性。单向 channel 限制了 channel 的使用方式，使得代码更具可读性，更容易理解方法的功能。而双向 channel 更灵活，可以在发送方和接收方之间双向传递数据。

使用单向 channel 类型约束的一个好处是，它可以帮助编译器检查代码的正确性。当你明确指定一个 channel 只能用于发送或接收数据时，编译器可以确保你在方法内部正确地使用了 channel。这有助于减少潜在的错误和提高代码质量。

func processData(ch chan int) {
    // 在这里，你可以向 ch 发送数据，也可以从 ch 接收数据
}
func sendData(ch chan<- int) {
    // 在这里，你可以向 ch 发送数据，但不能从 ch 接收数据
}

go 并发相关操作示例

启动 `goroutine`

使用 go 关键字来启动一个新的 goroutine

package main

import (
 "fmt"
 "time"
)

func printNumbers() {
 for i := 1; i <= 5; i++ {
 fmt.Printf("%d ", i)
 time.Sleep(1 * time.Second)
 }
}

func main() {
 go printNumbers() // 启动一个新的goroutine来执行printNumbers函数

 // 主goroutine继续执行
 for i := 6; i <= 10; i++ {
 fmt.Printf("%d ", i)
 time.Sleep(1 * time.Second)
 }
}

在上面的示例中，printNumbers函数在一个新的goroutine中执行，而主goroutine继续执行后面的代码。

使用 `channel` 进行通信

channel 是 Go 语言中用于在 goroutine 之间进行通信的管道。可以使用 make 函数创建一个 channel，并使用 <- 操作符向 channel 发送或接收数据。

package main

import (
 "fmt"
 "time"
)

func sendNumbers(ch chan<- int) {
 for i := 1; i <= 5; i++ {
 ch <- i // 向channel发送数据
 time.Sleep(1 * time.Second)
 }
 close(ch) // 关闭channel
}

func main() {
 ch := make(chan int) // 创建一个int类型的channel

 go sendNumbers(ch)   // 启动一个新的goroutine来发送数据到channel

 for num := range ch { // 从channel接收数据，直到channel被关闭
 fmt.Printf("%d ", num)
 }
}

在上面的示例中，sendNumbers 函数在一个新的 goroutine 中执行，并通过 channel 发送数据。主 goroutine 从 channel 接收数据，直到 channel 被关闭。

等待 `goroutine` 返回数据再继续执行主程序

package main

import (
    "fmt"
    "time"
)

func calculate(n int) int {
    time.Sleep(time.Second) // 模拟耗时操作
    return n * n
}

func main() {
    ch := make(chan int) // 创建一个channel

    go func() {
        result := calculate(5) // 执行计算操作
        ch <- result // 将结果发送到channel
    }()

    // 从channel接收数据，直到接收到结果为止
    for {
        select {
        case result := <-ch:
            fmt.Println("Result:", result) // 打印结果
            return
        default:
            fmt.Println("Waiting...") // 等待中...
            time.Sleep(500 * time.Millisecond)
        }
    }
}

在上面的示例中，我们定义了一个calculate函数，用于模拟一个耗时的计算操作。在main函数中，我们创建了一个channel，并使用匿名函数启动了一个新的goroutine来执行计算操作，并将结果发送到channel。

然后，我们在主线程中使用for循环和select语句从channel接收数据。如果接收到结果，就打印结果并退出循环；否则，在default分支中等待一段时间后再次尝试接收数据。

由于channel是无缓冲的，因此在发送和接收数据时会阻塞，直到另一端准备好进行通信为止。这样可以确保在接收到结果之前，主线程会一直等待。

带缓冲的 channel

package main

import (
 "fmt"
 "time"
)

func producer(ch chan<- int) {
 for i := 1; i <= 5; i++ {
 ch <- i // 向channel发送数据
 fmt.Printf("Producer sent %d\n", i)
 time.Sleep(time.Second)
 }
 close(ch) // 关闭channel
}

func consumer(ch <-chan int, done chan<- bool) {
 for num := range ch { // 从channel接收数据，直到channel被关闭
 fmt.Printf("Consumer received %d\n", num)
 time.Sleep(2 * time.Second) // 模拟耗时操作
 }
 done <- true // 发送完成信号到done channel
}

func main() {
 ch := make(chan int, 3) // 创建一个带缓冲的channel，缓冲区大小为3
 done := make(chan bool) // 创建一个用于接收完成信号的channel

 go producer(ch) // 启动生产者goroutine
 go consumer(ch, done) // 启动消费者goroutine

 <-done // 等待完成信号
 fmt.Println("All work done!")
}

我们创建了一个带缓冲的channel ch，其缓冲区大小为3。这意味着在channel中最多可以存储3个元素，而不需要等待接收方准备好进行通信。如果发送方发送数据的速度快于接收方处理数据的速度，那么channel中的缓冲区可以暂存这些数据，直到接收方准备好接收。这样可以避免阻塞和死锁等问题，提高程序的并发性能。

我们还创建了一个done channel，用于接收完成信号。producer函数向ch中发送数据，并在发送完所有数据后关闭ch。consumer函数从ch中接收数据，并在接收到所有数据后向done发送完成信号。

sync.WaitGroup

sync.WaitGroup 用于等待一组 goroutine 完成。它提供了一种机制，可以让一个或多个 goroutine 等待一组其他的 goroutine 完成执行。sync.WaitGroup 的方法包括：

Add(n int): 增加等待组的计数器。
Done(): 表示一个 goroutine 完成了它的工作，减少等待组的计数器。
Wait(): 阻塞，直到等待组的计数器归零。

package main

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

func worker(id int, wg *sync.WaitGroup) {
	// 在函数退出时调用 Done 来通知 main 函数工作已经完成
	defer wg.Done()

	fmt.Printf("Worker %d starting\n", id)

	// 模拟耗时任务
	time.Sleep(time.Second)
	fmt.Printf("Worker %d done\n", id)
}

func main() {
	// 创建一个 WaitGroup
	var wg sync.WaitGroup

	// 启动多个 goroutine
	for i := 1; i <= 5; i++ {
		// 每启动一个 goroutine，就把 WaitGroup 的计数器加 1
		wg.Add(1)
		go worker(i, &wg)
	}

	// 等待所有的 goroutine 完成
	wg.Wait()
	fmt.Println("All workers done")
}

在这个示例中，我们创建了一个 sync.WaitGroup 实例 wg。对于每个启动的 goroutine，我们调用 wg.Add(1) 来增加等待组的计数器。在每个 worker 函数中，我们使用 defer wg.Done() 来确保 goroutine 完成时计数器会减少。最后，在 main 函数中，我们调用 wg.Wait() 来阻塞，直到所有的 goroutine 都调用了 Done 方法，计数器变为 0，这时 main 函数才会继续执行。

这种方式可以确保 main 函数在所有 goroutine 完成工作后再退出，避免了潜在的竞态条件和数据丢失问题。

sync.WaitGroup 在以下场景下特别有用：

并发任务执行：当你需要并发地执行多个任务（通常是通过 goroutine），并且需要等待所有任务完成后再进行下一步操作时，sync.WaitGroup 非常有用。
并发处理数据：在处理数据集或集合时，如果你想要并行处理每个元素，可以使用 sync.WaitGroup 来等待所有数据处理完成。
服务启动：在启动多个服务或服务器实例时，你可能需要等待所有实例都启动成功后再进行其他操作，这时 sync.WaitGroup 可以帮助你实现这一点。
资源清理：在进行一系列的资源清理工作时，你可能需要确保所有清理任务都完成后才继续执行，例如关闭文件句柄、网络连接等。
测试和基准测试：在进行性能测试或编写测试用例时，可能需要等待多个并发执行的测试逻辑全部完成后再收集结果或进行断言。
数据聚合：当从多个源并发地聚合数据时，sync.WaitGroup 可以用来确保所有数据都被处理完毕后才进行聚合操作。
限制并发数量：在某些情况下，你可能需要限制同时运行的 goroutine 数量，而 sync.WaitGroup 可以与通道（channel）结合使用，来实现这种并发控制。
分布式系统同步：在分布式系统中，sync.WaitGroup 可以用来同步不同节点上的任务执行状态。

`sync.Pool`

sync.Pool 是一个对象池，用于存储和复用临时对象，以减少内存分配和垃圾回收的开销。sync.Pool 的方法包括：

Get(): 获取一个对象。如果池中没有可用对象，将返回一个新的对象。
Put(x interface{}): 将一个对象放回池中。
New: 一个函数类型，当调用 Get 方法且池中没有可用对象时，将调用此函数来创建一个新对象。

sync.Pool 通常用于以下场景：

需要频繁创建和销毁临时对象的场景，如数据库连接池、线程池等。
减少内存分配和垃圾回收的压力。

package main

import (
	"fmt"
	"sync"
)

// 假设我们有一个结构体，它代表一个临时对象
type TempBuffer struct {
	buffer []byte
}

// 创建一个新的 TempBuffer 对象
func newTempBuffer(size int) *TempBuffer {
	return &TempBuffer{
		buffer: make([]byte, size),
	}
}

// 实现 sync.Pool 的 New 方法
func tempBufferPoolNew(size int) func() interface{} {
	return func() interface{} {
		return newTempBuffer(size)
	}
}

func main() {
	// 创建一个 TempBuffer 对象池
	pool := sync.Pool{
		New: tempBufferPoolNew(1024), // 当调用 Get 方法且池中没有可用对象时，将调用此函数来创建一个新对象
	}

	// 从池中获取一个对象
	tempBuf := pool.Get().(*TempBuffer)
	fmt.Printf("Using buffer with length %d\n", len(tempBuf.buffer))

	// 使用完对象后，将其放回池中
	pool.Put(tempBuf)

	// 再次从池中获取对象，这次会复用之前放回的对象
	tempBuf = pool.Get().(*TempBuffer)
	fmt.Printf("Reusing buffer with length %d\n", len(tempBuf.buffer))

	// 清理池中的所有对象（可选操作）
	// 注意：通常不需要手动清理，因为垃圾回收器会自动处理不再使用的对象
	// pool.Reset()
}

在这个例子中，我们定义了一个 TempBuffer 结构体，它包含一个字节切片。我们创建了一个 sync.Pool 实例，并为其提供了一个 New 函数，该函数在被调用时会创建一个新的 TempBuffer 对象。

在 main 函数中，我们首先从池中获取一个 TempBuffer 对象，使用完毕后将其放回池中。当我们再次从池中获取对象时，如果池中有可用的对象，就会复用之前放回的对象，而不是创建一个新的对象。这样可以减少内存分配和垃圾回收的开销，提高性能。

需要注意的是，sync.Pool 并不保证池中的对象始终可用或始终为空，它只是提供了一种机制来存储和复用临时对象。此外，由于 sync.Pool 中的对象可能会在不同的 goroutine 之间共享，因此在对象放回池中之前，应该确保对象的状态是安全的，不会导致数据竞争或其他并发问题。

互斥锁（mutexes）

在Go语言中，互斥锁（mutexes）是一种用于保护共享资源的方式，它可以确保在同一时间只有一个协程（goroutine）可以访问共享资源。Go的sync包提供了Mutex类型来实现互斥锁。

package main

import (
	"fmt"
	"sync"
)

type Counter struct {
	value int
	mu    sync.Mutex // 声明一个互斥锁
}

func (c *Counter) Increment() {
	c.mu.Lock()         // 在修改值之前加锁
	c.value++          // 修改值
	c.mu.Unlock()       // 修改完成后解锁
}

func (c *Counter) GetValue() int {
	c.mu.Lock()         // 在读取值之前加锁
	defer c.mu.Unlock() // 使用defer确保函数结束时解锁
	return c.value      // 返回值
}

func main() {
	var wg sync.WaitGroup
	counter := Counter{}

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			counter.Increment()
			wg.Done()
		}()
	}

	wg.Wait()
	fmt.Println("Counter value:", counter.GetValue())
}

在这个示例中，我们定义了一个Counter结构体，它包含一个整数值和一个互斥锁。我们为Counter定义了两个方法：Increment用于增加计数器的值，GetValue用于获取计数器的值。在这两个方法中，我们使用互斥锁来确保在同一时间只有一个协程可以访问和修改计数器的值。

在main函数中，我们创建了10个协程，每个协程都会调用Increment方法来增加计数器的值。我们使用sync.WaitGroup来等待所有协程完成，然后输出计数器的最终值。

需要注意的是，在使用互斥锁时，要确保在适当的时候释放锁，以避免死锁（deadlock）的发生。在上面的示例中，我们在GetValue方法中使用defer语句来确保在函数结束时释放锁。

在Go语言中，除了互斥锁（Mutex），还有其他几种锁机制，它们都位于sync包中，主要用于不同场景下的并发控制。

读写锁（RWMutex）
自旋锁（Mutex的一个变种，如sync.Mutex实际上是一个自旋锁的封装）
条件变量（Cond）
通道（Channel）

常见的并发问题以及如何避免

1. 竞态条件（Race Condition）

当多个线程/协程并发访问同一资源，并且至少有一个线程/协程在写入时，就可能发生竞态条件。这可能导致程序的行为不可预测。

避免方法:

使用互斥锁（mutexes）或其他同步原语来保护共享资源。
使用原子操作来避免锁的开销，同时保证线程安全。
使用无锁数据结构，如并发安全的队列、栈等。

2. 死锁（Deadlock）

当两个或多个线程/协程互相等待对方释放资源时，就会发生死锁。

避免方法:

使用锁的顺序规则，确保所有线程/协程以相同的顺序请求锁。
使用锁超时或尝试锁定操作，以便在无法获取锁时能够继续执行。
使用死锁检测算法，如银行家算法。

3. 饥饿（Starvation）

当一个线程/协程长时间无法获得所需资源时，就会发生饥饿。

避免方法:

使用公平锁策略，确保所有线程/协程都有机会获得锁。
使用工作窃取算法来平衡负载，防止某些线程/协程长时间空闲。

4. 活锁（Livelock）

当两个或多个线程/协程不断重复相同的操作，但总是被对方的行为所抵消，导致无法取得进展时，就会发生活锁。

避免方法:

使用随机化策略来打破循环依赖。
使用状态机来协调线程/协程的行为。

5. 数据竞争（Data Race）

当多个线程/协程并发访问同一内存位置，并且至少有一个是写操作时，就可能发生数据竞争。

避免方法:

使用内存屏障或原子操作来保证内存访问的顺序性。
使用静态分析工具来检测和修复潜在的竞争条件。

6. 资源泄漏（Resource Leak）

当程序不再需要某个资源（如文件句柄、网络连接等），但没有正确释放时，就会发生资源泄漏。

避免方法:

使用资源管理库或上下文管理器来自动管理资源的生命周期。
在代码中显式地释放资源，并确保在所有可能的退出路径上都执行释放操作。

7. 异常安全性（Exception Safety）

当异常发生时，如果资源没有被正确释放，就可能导致异常安全性问题。

避免方法:

使用RAII（Resource Acquisition Is Initialization）模式，确保资源在对象生命周期结束时被自动释放。
在异常处理代码中显式地释放资源。

最佳实践

避免共享状态：尽量减少 goroutines 之间的共享状态，转而使用 channels 进行通信。
正确关闭 Channels：在使用完 channels 后，应该正确地关闭它们，以避免死锁和资源泄漏。
使用缓冲 Channels：在需要的时候，使用缓冲 channels 可以减少 goroutines 之间的同步等待时间。
合理控制并发数量：虽然 goroutines 非常轻量，但是创建过多的 goroutines 可能会导致调度开销增加，因此应该合理控制并发数量。