跳至主要內容

GO语言的Channel

MorseWayne2025/9/5...大约 6 分钟Go

1. 什么是 Channel

Channel 是 Go 语言中用于在不同 goroutine 之间进行通信的管道。它允许一个 goroutine 向另一个 goroutine 发送数据，实现了 goroutine 之间的同步和数据交换。

核心特性：

  • 类型化：每个 channel 只能传输特定类型的数据
  • 线程安全：Channel 的设计保证了在多个 goroutine 之间的安全访问
  • 同步或异步：根据是否有缓冲区，分为同步和异步两种工作模式

2. Channel 的基本语法

2.1 创建 Channel

// 创建无缓冲channel
unbufferedCh := make(chan int)

// 创建带缓冲channel（容量为10）
bufferedCh := make(chan string, 10)

// 创建只读channel
readOnlyCh := make(<-chan int)

// 创建只写channel
writeOnlyCh := make(chan<- int)

2.2 基本操作

// 发送数据到channel
bufferedCh <- "hello"

// 从channel接收数据
data := <-bufferedCh

// 忽略接收的值
<-bufferedCh

// 关闭channel
close(bufferedCh)

// 检查channel是否已关闭
value, ok := <-bufferedCh // ok为false表示channel已关闭且无数据

3. 无缓冲 Channel

3.1 核心特性

无缓冲 channel 是指没有缓冲区的 channel，创建时不指定容量参数。其关键特性是严格同步：

  1. 发送操作会阻塞：当一个 goroutine 向无缓冲 channel 发送数据时，它会被阻塞，直到另一个 goroutine 从该 channel 接收数据
  2. 接收操作会阻塞：当一个 goroutine 从无缓冲 channel 接收数据时，它会被阻塞，直到另一个 goroutine 向该 channel 发送数据
  3. 数据直接传递：数据直接从发送方 goroutine 传递到接收方 goroutine，不会在 channel 中存储

3.2 代码示例

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int)  // 无缓冲channel
    
    go func() {
        fmt.Println("接收方：等待接收数据")
        data := <-ch  // 阻塞等待数据
        fmt.Println("接收方：收到数据", data)
    }()
    
    time.Sleep(1 * time.Second)  // 确保接收方先运行
    
    fmt.Println("发送方：准备发送数据")
    ch <- 42  // 阻塞等待接收方接收
    fmt.Println("发送方：数据发送完成")
}

3.3 执行结果

接收方：等待接收数据
发送方：准备发送数据
接收方：收到数据 42
发送方：数据发送完成

4. 带缓冲 Channel

4.1 核心特性

带缓冲 channel 创建时指定了容量（缓冲区大小），其关键特性是异步为主，必要时同步：

  1. 发送操作的表现：

    • 当缓冲区未满时，发送操作会立即返回，不会阻塞
    • 当缓冲区已满时，发送操作会被阻塞，直到有数据被接收方取走

  2. 接收操作的表现：

    • 当缓冲区非空时，接收操作会立即返回，不会阻塞
    • 当缓冲区为空时，接收操作会被阻塞，直到有新数据被发送方写入

4.2 代码示例

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 2)  // 容量为2的带缓冲channel
    
    fmt.Println("初始缓冲区容量:", cap(ch))  // 输出：初始缓冲区容量: 2
    fmt.Println("初始缓冲区长度:", len(ch))  // 输出：初始缓冲区长度: 0
    
    // 缓冲区未满，发送不会阻塞
    ch <- 1
    fmt.Println("发送数据1后，缓冲区长度:", len(ch))  // 输出：发送数据1后，缓冲区长度: 1
    
    ch <- 2
    fmt.Println("发送数据2后，缓冲区长度:", len(ch))  // 输出：发送数据2后，缓冲区长度: 2
    
    // 启动goroutine接收数据
    go func() {
        time.Sleep(1 * time.Second)
        data := <-ch
        fmt.Println("接收数据1，缓冲区长度:", len(ch))  // 输出：接收数据1，缓冲区长度: 1
        
        time.Sleep(1 * time.Second)
        data = <-ch
        fmt.Println("接收数据2，缓冲区长度:", len(ch))  // 输出：接收数据2，缓冲区长度: 0
    }()
    
    // 缓冲区已满，发送会阻塞，直到有数据被接收
    fmt.Println("尝试发送数据3...")
    ch <- 3
    fmt.Println("发送数据3成功，缓冲区长度:", len(ch))  // 输出：发送数据3成功，缓冲区长度: 1
}

5. 无缓冲 vs 带缓冲 Channel

特性无缓冲 Channel带缓冲 Channel
创建方式make(chan Type)make(chan Type, capacity)
同步性严格同步，发送和接收必须配对异步为主，仅在缓冲区满/空时阻塞
数据存储无中间存储，直接传递有中间缓冲区存储数据
适用场景严格的同步通信、信号通知生产者-消费者模式、流量控制
阻塞行为发送和接收操作总是会阻塞仅在特定条件下阻塞

6. 常见使用模式

6.1 信号通知

使用无缓冲 channel 实现 goroutine 之间的信号通知：

func worker(done chan bool) {
    // 执行任务
    time.Sleep(2 * time.Second)
    fmt.Println("工作完成")
    
    // 发送完成信号
    done <- true
}

func main() {
    done := make(chan bool)
    go worker(done)
    
    // 等待工作完成
    <-done
    fmt.Println("主程序继续执行")
}

6.2 生产者-消费者模式

使用带缓冲 channel 实现生产者-消费者模式：

func producer(ch chan<- int) {
    for i := 0; i < 10; i++ {
        ch <- i  // 向channel发送数据
        fmt.Println("生产者: 生产了", i)
        time.Sleep(time.Millisecond * 100)
    }
    close(ch)  // 生产完成后关闭channel
}

func consumer(ch <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    
    // 循环读取channel，直到channel关闭且为空
    for data := range ch {
        fmt.Println("消费者: 消费了", data)
        time.Sleep(time.Millisecond * 500)  // 消费者处理速度较慢
    }
}

func main() {
    ch := make(chan int, 5)  // 缓冲区大小为5
    var wg sync.WaitGroup
    
    wg.Add(2)  // 两个消费者
    
    go producer(ch)
    go consumer(ch, &wg)
    go consumer(ch, &wg)
    
    wg.Wait()  // 等待所有消费者完成
}

6.3 使用 select 多路复用

select 语句可以同时监听多个 channel 的操作：

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)
    
    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "来自通道1的数据"
    }()
    
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "来自通道2的数据"
    }()
    
    // 监听两个channel，哪个先有数据就处理哪个
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println("收到", msg1)
        case msg2 := <-ch2:
            fmt.Println("收到", msg2)
        case <-time.After(3 * time.Second):
            fmt.Println("超时")
            return
        }
    }
}

6.5 限制goroutine数量

package main

import "time"

var limit = make(chan int, 3)
var workers = []func(idx int){
	func(idx int) {
		println("work: ", idx)
		time.Sleep(time.Second)
	},
	func(idx int) {
		println("work: ", idx)
		time.Sleep(time.Second)
	},
	func(idx int) {
		println("work: ", idx)
		time.Sleep(time.Second)
	},
	func(idx int) {
		println("work: ", idx)
		time.Sleep(time.Second)
	},
	func(idx int) {
		println("work: ", idx)
		time.Sleep(time.Second)
	},
}

func main() {
	for idx, work := range workers {
		go func() {
			limit <- 1
			work(idx)
			<-limit
		}()
	}
	select {}
}

7. 注意事项与最佳实践

  1. 不要关闭已经关闭的 channel：这会导致 panic

  2. 避免向已关闭的 channel 发送数据：这会导致 panic

  3. 可以从已关闭的 channel 接收数据：当 channel 关闭后，仍然可以接收其中剩余的数据，直到 channel 为空，之后接收操作会返回零值和 false

  4. 使用 for range 读取 channel：这是读取 channel 的首选方式，它会自动处理 channel 关闭的情况

  5. 使用 sync.WaitGroup 等待多个 goroutine 完成：避免主程序过早退出导致 goroutine 未执行完成

  6. 合理设置带缓冲 channel 的容量：根据实际需求设置缓冲区大小，过大可能导致内存浪费，过小可能无法发挥异步优势

  7. 避免死锁：确保发送和接收操作在不同的 goroutine 中进行，避免单一 goroutine 中同时进行发送和接收导致死锁

  8. 优先使用无缓冲 channel：在不确定是否需要缓冲区时，优先使用无缓冲 channel，它提供了更严格的同步保证

通过合理使用 channel，你可以在 Go 程序中实现高效、安全的并发通信，充分发挥 Go 语言的并发优势。

Copyright © 2026 MorseWayne