Go语言并发基础：Goroutine与Channel
go语言以其内置的并发原语——goroutine和channel而闻名，它们使得编写并发程序变得简单而高效。goroutine是轻量级的执行线程，而channel则是goroutine之间进行通信的管道，遵循“通过通信共享内存”的并发哲学，而非“通过共享内存通信”。
一个基本的Go并发模型通常涉及两个或多个goroutine通过channel相互发送和接收数据。例如，以下代码展示了两个goroutine Routine1 和 Routine2 如何使用两个通道 commands 和 responses 进行交互：
package main
import (
"fmt"
"math/rand"
"time" // 导入time包以初始化随机数种子
)
// Routine1 发送整数到commands通道，并从responses通道接收响应
func Routine1(commands chan int, responses chan int) {
// 使用当前时间作为随机数种子，确保每次运行结果不同
rand.Seed(time.Now().UnixNano())
for i := 0; i < 10; i++ {
val := rand.Intn(100) // 生成0-99的随机数
commands <- val // 发送数据到commands通道
fmt.Printf("Routine1: Sent %d, Waiting for response...\n", val)
resp := <-responses // 从responses通道接收响应
fmt.Printf("Routine1: Received %d from Routine2\n", resp)
}
close(commands) // 完成发送后关闭commands通道
}
// Routine2 从commands通道接收整数，并发送响应到responses通道
func Routine2(commands chan int, responses chan int) {
rand.Seed(time.Now().UnixNano() + 1) // 不同的种子以确保独立性
for { // 持续接收，直到通道关闭
x, open := <-commands // 从commands通道接收数据，并检查通道是否关闭
if !open {
fmt.Println("Routine2: commands channel closed. Exiting.")
return // 如果通道关闭，则退出
}
fmt.Printf("Routine2: Received %d from Routine1\n", x)
y := rand.Intn(100) // 生成0-99的随机数作为响应
responses <- y // 发送响应到responses通道
fmt.Printf("Routine2: Sent %d to Routine1\n", y)
}
}
// 主函数负责创建通道并启动goroutine
func main() {
commands := make(chan int) // 创建用于发送命令的通道
responses := make(chan int) // 创建用于发送响应的通道
go Routine1(commands, responses) // 启动Routine1作为新的goroutine
Routine2(commands, responses) // 在当前goroutine中运行Routine2
// 为了确保Routine2有足够时间处理Routine1发送的数据，
// 并且在Routine1关闭commands通道后，Routine2能够优雅退出，
// 这里不需要额外的同步机制，因为Routine2的循环会持续到commands通道关闭。
// 但在实际应用中，可能需要sync.WaitGroup来等待所有goroutine完成。
fmt.Println("Main: All routines finished or main routine exited.")
}在上述代码中，main 函数创建了两个无缓冲通道 commands 和 responses。Routine1 负责向 commands 发送数据并从 responses 接收数据，而 Routine2 则相反。这种模式实现了两个goroutine之间的“请求-响应”通信。
引入第三个Goroutine与死锁问题分析
当尝试向现有并发模型中添加第三个goroutine，并让它与其他goroutine进行通信时，可能会遇到“all goroutines are asleep - deadlock!”的错误。这通常意味着所有的goroutine都在等待某个事件发生，但该事件永远不会发生，导致程序陷入僵局。
考虑以下尝试添加 Routine3 的代码：
立即学习“go语言免费学习笔记（深入）”；
package main
import (
"fmt"
"math/rand"
"time"
)
func Routine1(commands chan int, responses chan int, command3 chan int, response3 chan int) {
rand.Seed(time.Now().UnixNano())
for i := 0; i < 10; i++ {
val := rand.Intn(100)
commands <- val // 发送给Routine2
command3 <- val // 发送给Routine3
fmt.Printf("Routine1: Sent %d to R2 & R3\n", val)
resp2 := <-responses // 从Routine2接收响应
fmt.Printf("Routine1: Received %d from R2\n", resp2)
resp3 := <-response3 // 从Routine3接收响应
fmt.Printf("Routine1: Received %d from R3\n", resp3)
}
close(commands) // 关闭与Routine2相关的通道
close(command3) // 关闭与Routine3相关的通道
}
func Routine2(commands chan int, responses chan int) {
rand.Seed(time.Now().UnixNano() + 1)
for {
x, open := <-commands
if !open {
fmt.Println("Routine2: commands channel closed. Exiting.")
return
}
fmt.Printf("Routine2: Received %d from R1\n", x)
y := rand.Intn(100)
responses <- y
fmt.Printf("Routine2: Sent %d to R1\n", y)
}
}
func Routine3(command3 chan int, response3 chan int) {
rand.Seed(time.Now().UnixNano() + 2)
for {
x, open := <-command3
if !open {
fmt.Println("Routine3: command3 channel closed. Exiting.")
return
}
fmt.Printf("Routine3: Received %d from R1\n", x)
y := rand.Intn(100)
response3 <- y
fmt.Printf("Routine3: Sent %d to R1\n", y)
}
}
func main() {
commands := make(chan int)
responses := make(chan int)
// 错误根源：此处缺少对 command3 和 response3 通道的初始化
// command3 := make(chan int) // 正确的初始化
// response3 := make(chan int) // 正确的初始化
go Routine1(commands, responses, nil, nil) // 传递了nil通道，导致死锁
Routine2(commands, responses)
// Routine3(command3, response3) // 如果上面未初始化，这里会使用未初始化的通道
}上述代码中导致死锁的根本原因在于 main 函数中，传递给 Routine1 的 command3 和 response3 参数实际上是 nil。在Go语言中，对一个 nil 通道进行发送或接收操作会导致goroutine永久阻塞，进而引发死锁。这是因为 nil 通道永远不会准备好进行通信。
修正方法： 要解决这个问题，必须在 main 函数中正确地初始化所有通道，即使用 make 函数创建它们：
package main
import (
"fmt"
"math/rand"
"time"
"sync" // 引入sync包用于goroutine同步
)
func Routine1(commands chan int, responses chan int, command3 chan int, response3 chan int, wg *sync.WaitGroup) {
defer wg.Done() // goroutine结束时通知WaitGroup
rand.Seed(time.Now().UnixNano())
for i := 0; i < 10; i++ {
val := rand.Intn(100)
commands <- val
command3 <- val
fmt.Printf("Routine1: Sent %d to R2 & R3\n", val)
resp2 := <-responses
fmt.Printf("Routine1: Received %d from R2\n", resp2)
resp3 := <-response3
fmt.Printf("Routine1: Received %d from R3\n", resp3)
}
close(commands)
close(command3)
fmt.Println("Routine1: Finished and closed channels.")
}
func Routine2(commands chan int, responses chan int, wg *sync.WaitGroup) {
defer wg.Done()
rand.Seed(time.Now().UnixNano() + 1)
for {
x, open := <-commands
if !open {
fmt.Println("Routine2: commands channel closed. Exiting.")
return
}
fmt.Printf("Routine2: Received %d from R1\n", x)
y := rand.Intn(100)
responses <- y
fmt.Printf("Routine2: Sent %d to R1\n", y)
}
}
func Routine3(command3 chan int, response3 chan int, wg *sync.WaitGroup) {
defer wg.Done()
rand.Seed(time.Now().UnixNano() + 2)
for {
x, open := <-command3
if !open {
fmt.Println("Routine3: command3 channel closed. Exiting.")
return
}
fmt.Printf("Routine3: Received %d from R1\n", x)
y := rand.Intn(100)
response3 <- y
fmt.Printf("Routine3: Sent %d to R1\n", y)
}
}
func main() {
commands := make(chan int)
responses := make(chan int)
command3 := make(chan int) // 正确初始化
response3 := make(chan int) // 正确初始化
var wg sync.WaitGroup // 使用WaitGroup等待所有goroutine完成
wg.Add(3) // 增加计数器，因为有3个goroutine需要等待
go Routine1(commands, responses, command3, response3, &wg)
go Routine2(commands, responses, &wg) // Routine2也作为goroutine启动
go Routine3(command3, response3, &wg) // Routine3也作为goroutine启动
wg.Wait() // 等待所有goroutine完成
fmt.Println("Main: All goroutines have finished.")
}通过将 Routine2 和 Routine3 也作为独立的goroutine启动，并使用 sync.WaitGroup 来等待所有goroutine完成，确保 main 函数不会过早退出，从而允许所有并发操作正常执行。
通道方向性与“双向”通信
Go语言的通道在概念上是单向的，即数据只能从发送端流向接收端。然而，一个通道变量本身可以用于发送和接收操作。所谓的“双向”通信，通常是通过使用两个单向通道来实现的：一个用于请求，另一个用于响应。
例如，在我们的示例中，Routine1 通过 commands 通道向 Routine2 发送数据，而 Routine2 则通过 responses 通道将数据回传给 Routine1。这正是实现双向通信的标准模式。
在函数签名中，可以明确指定通道的方向性，以提高代码的可读性和安全性：
- chan
- chan int: 表示一个既可以发送也可以接收 int 类型数据的通道。
例如，Routine1 的签名可以更精确地定义为：
func Routine1(commands chan<- int, responses <-chan int, command3 chan<- int, response3 <-chan int, wg *sync.WaitGroup) {
// ...
}这样，编译器会在编译时检查对通道的操作是否符合其声明的方向性，从而避免潜在的错误。
泛型通道与类型安全
关于是否可以创建一个“通用通道”来传递 int、string 等不同类型的数据，Go语言的通道是类型安全的。这意味着一个通道在创建时就确定了它能传输的数据类型，例如 chan int 只能传输整数，chan string 只能传输字符串。
如果确实需要在一个通道中传递多种类型的数据，可以考虑以下两种方法：
-
使用 interface{} 类型：interface{} 是Go语言中的空接口，可以表示任何类型的值。因此，可以创建一个 chan interface{} 来传输不同类型的数据。
dataChannel := make(chan interface{}) go func() { dataChannel <- 123 // 发送整数 dataChannel <- "hello world" // 发送字符串 dataChannel <- true // 发送布尔值 close(dataChannel) }() for val := range dataChannel { switch v := val.(type) { // 使用类型断言判断接收到的数据类型 case int: fmt.Printf("Received an int: %d\n", v) case string: fmt.Printf("Received a string: %s\n", v) case bool: fmt.Printf("Received a bool: %t\n", v) default: fmt.Printf("Received an unknown type: %T\n", v) } }使用 interface{} 的缺点是需要进行类型断言 (val.(type)) 来恢复原始类型，这会增加运行时开销，并可能导致类型断言失败（如果类型不匹配）的运行时错误。
-
Go 1.18+ 的泛型（Generics）： Go 1.18 引入了泛型特性，允许编写更通用、类型安全的代码。虽然泛型主要用于数据结构和函数，但其理念也可以应用于构建更灵活的通道处理逻辑，例如，可以定义一个泛型函数来处理不同类型的通道，而不是直接创建一个泛型通道。
// 这是一个泛型函数示例，而非泛型通道本身 func processChannel[T any](ch <-chan T) { for val := range ch { fmt.Printf("Processing value: %v (type: %T)\n", val, val) } } // 在main函数中调用 intCh := make(chan int) go func() { intCh <- 1 intCh <- 2 close(intCh) }() processChannel(intCh) // 可以处理int类型的通道 stringCh := make(chan string) go func() { stringCh <- "a" stringCh <- "b" close(stringCh) }() processChannel(stringCh) // 也可以处理string类型的通道直接创建 chan[T] T 这样的泛型通道在Go语言中是不支持的，通道的类型参数必须是具体的类型。但泛型函数可以帮助你编写处理不同类型通道的通用逻辑。
总结与注意事项
- 通道初始化： 永远使用 make(chan Type) 来初始化通道。对 nil 通道的发送或接收操作会导致死锁。
- 通道关闭： 当不再有数据发送时，关闭通道是一个好习惯。接收方可以通过 value, open :=
- 并发同步： 在复杂的并发场景中，除了通道，还可以使用 sync.WaitGroup 来等待所有goroutine完成，确保主goroutine不会过早退出。
- 错误处理： 生产环境代码应包含健壮的错误处理机制，例如使用 select 语句处理多个通道操作或超时。
- 通道缓冲： make(chan Type, capacity) 可以创建带缓冲的通道。无缓冲通道（capacity=0 或省略）要求发送和接收操作同时进行，而带缓冲通道允许在缓冲区满或空之前进行非阻塞操作。选择合适的缓冲大小对性能和死锁预防至关重要。
通过理解和正确应用Go语言的goroutine和channel机制，开发者可以构建出高效、健壮且易于维护的并发应用程序。避免常见的死锁陷阱，并根据需求选择合适的通道类型和通信模式，是掌握Go并发编程的关键。
