Go Channel 管道使用示例解析

Channel 的定义与基础语法

Channel 必须指定发送值的类型，可使用内置函数 make 创建。基本语法如下：

• 无缓冲 Channel：ch := make(chan int)，等价于容量为 0 的创建方式。
• 有缓冲 Channel：ch := make(chan Type, capacity)，指定缓冲区大小。

数据写入与读取操作

通过箭头运算符 <- 进行数据的发送和接收，方向表示数据流动的方向：

• 写入数据：ch <- 666，将值放入通道。
• 接收并丢弃：<- ch，从通道取值但不保存。
• 接收并赋值：x := <- ch，将接收的值赋给变量 x。
• 检查通道状态：x, ok := <- ch，返回接收到的值和布尔标志 ok。若 ok 为 false，表示通道已关闭且无数据。

缓冲机制与阻塞原理

Channel 的行为取决于其容量 capacity：

1. 无缓冲 (Capacity=0)：读写操作均会阻塞，直到另一端准备好。这是一种同步机制，常用于 Goroutine 间的信号通知或简单同步。
2. 有缓冲 (Capacity>0)：写入时，如果缓冲区未满则不阻塞；读操作时，如果有数据则立即返回。当缓冲区满时写入阻塞，为空时读取阻塞。

注意：默认情况下，除非另一端准备就绪，否则 Channel 的接收和发送都会阻塞，从而简化了 Goroutine 的同步，无需显式使用锁（Lock）。

实战：Channel 实现协程同步

以下代码展示了如何使用无缓冲 Channel 等待子协程执行完毕。主协程在接收到消息前会一直阻塞：

package main

import (
	"fmt"
	"time"
)

func main() {
	// 创建无缓冲 channel
	ch := make(chan string)
	defer fmt.Println("主协程也结束")

	go func() {
		defer fmt.Println("子协程调用完毕")
		// 模拟工作
		for i := 0; i < 2; i++ {
			fmt.Println("子协程 i = ", i)
			time.Sleep(time.Second)
		}
		// 发送完成信号
		ch <- "我是子协程，要工作完毕"
	}()

	// 阻塞等待数据
	str := <-ch
	fmt.Println("str = ", str)
}

无缓冲 Channel 的实时协作

在无缓冲模式下，生产者与消费者必须交替进行。以下示例中，生产者每秒写入一个数，消费者随即读取：

package main

import (
	"fmt"
	"time"
)

func main() {
	// 无缓冲 channel
	ch := make(chan int, 0)
	fmt.Printf("len(ch) = %d, cap(ch)= %d\n", len(ch), cap(ch))

	go func() {
		for i := 0; i < 10000; i++ {
			fmt.Printf("子协程：i = %d\n", i)
			ch <- i // 写操作，若无接收则阻塞
			time.Sleep(1 * time.Second)
		}
	}()

	go func() {
		for {
			num := <-ch // 读操作，若无数据则阻塞
			fmt.Println("num = ", num)
		}
	}()

	// 主协程保持运行以维持子协程执行
	for {
	}
}

有缓冲 Channel 的应用场景

有缓冲 Channel 允许在一段时间内积累数据。以下代码展示了当缓冲区大小为 3 时的行为，写操作在未写满前不会阻塞：

package main

import (
	"fmt"
	"time"
)

func main() {
	// 创建有缓冲 channel，容量为 3
	ch := make(chan int, 3)
	fmt.Printf("len(ch) = %d, cap(ch)= %d\n", len(ch), cap(ch))

	go func() {
		for i := 0; i < 10; i++ {
			ch <- i
			fmt.Printf("子协程[%d]: len(ch) = %d, cap(ch)= %d\n", i, len(ch), cap(ch))
		}
	}()

	// 延时等待子协程填充缓冲区
	time.Sleep(2 * time.Second)

	// 依次读取所有数据
	for i := 0; i < 10; i++ {
		num := <-ch
		fmt.Println("num = ", num)
	}
}

正确关闭 Channel

只有生产者应该关闭 Channel，消费者不应关闭。通过 value, ok := <- ch 可以判断 Channel 是否关闭且无剩余数据。

package main

import (
	"fmt"
)

func main() {
	ch := make(chan int, 3)
	fmt.Printf("len(ch) = %d, cap(ch)= %d\n", len(ch), cap(ch))

	go func() {
		for i := 0; i < 10000; i++ {
			fmt.Printf("子协程：i = %d\n", i)
			ch <- i
			if i > 10 {
				close(ch) // 生产者关闭通道
				break
			}
		}
	}()

	go func() {
		for {
			if num, ok := <-ch; ok {
				fmt.Println("num = ", num)
			} else {
				// 通道已关闭且数据取完
				break
			}
		}
	}()

	// 保持主进程运行
	for {
	}
}

单向 Channel：读写分离

可以将双向 Channel 隐式转换为单向 Channel，以实现接口级别的读写隔离：

• chan<- int：只写通道（数据流入）。
• <-chan int：只读通道（数据流出）。

单向通道不能转换回双向通道。这有助于提高程序的安全性，防止误操作。

package main

// import "fmt"

func main() {
	// 创建双向 channel
	ch := make(chan int)

	// 转换为单向通道
	var writeCh chan<- int = ch // 只能写
	var readCh <-chan int = ch  // 只能读

	writeCh <- 666          // 合法写入
	<-readCh                // 合法读取

	// <-writeCh // 错误：不能从只写通道接收
	// readCh <- 666 // 错误：不能向只读通道发送

	// var ch3 chan int = writeCh // 错误：单向转双向非法
}

实战：生产者-消费者模型

利用单向通道可以更清晰地表达意图。生产者负责写入并关闭通道，消费者负责遍历读取。

package main

import (
	"fmt"
)

// 生产者：只能往 out 写
func producer(out chan<- int) {
	for i := 0; i < 10; i++ {
		out <- i * i
	}
	close(out)
}

// 消费者：只能从 data 读
func consumer(data <-chan int) {
	for num := range data {
		fmt.Println("num = ", num)
	}
}

func main() {
	ch := make(chan int)
	go producer(ch)
	consumer(ch)
}

以上就是Go语言 channel 管道的详细内容，更多关于 channel 管道的资料请关注本站其它相关文章！