Go的Channel通过通信共享内存，避免数据竞争，简化并发编程。其阻塞机制天然同步，支持无缓冲、有缓冲通信，结合select实现超时、取消等复杂控制，是Go并发的核心。
Golang的Channel是其并发模型的核心，提供了一种安全、高效的goroutine间通信机制。简单来说，它就是一个管道，让数据可以在不同的并发执行单元之间流动，极大地简化了并发编程的复杂性。无论是传递数据、同步协程，还是处理复杂的并发模式，Channel都扮演着不可或缺的角色，其设计哲学完美诠释了Go语言“通过通信共享内存，而不是通过共享内存来通信”的理念。
package main
import (
"fmt"
"sync"
"time"
)
func main() {
fmt.Println("--- Golang Channel 创建与通信示例 ---")
// 1. 无缓冲通道 (Unbuffered Channel)
// 创建一个无缓冲的字符串通道。这意味着发送和接收操作会立即阻塞，直到另一端就绪。
messages := make(chan string)
var wg sync.WaitGroup // 用于等待goroutine完成
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println("[发送者]：准备发送 '你好，无缓冲世界！'")
messages <- "你好，无缓冲世界！" // 尝试发送，会阻塞直到main goroutine准备好接收
fmt.Println("[发送者]：'你好，无缓冲世界！' 已发送。")
}()
fmt.Println("[接收者]：准备接收无缓冲消息...")
msg := <-messages // 尝试接收，会阻塞直到发送者发送消息
fmt.Printf("[接收者]：收到无缓冲消息: '%s'\n", msg)
fmt.Println("[接收者]：无缓冲消息处理完毕。")
wg.Wait() // 等待发送者goroutine完成，确保输出顺序
fmt.Println("\n---")
// 2. 有缓冲通道 (Buffered Channel)
// 创建一个容量为2的整数缓冲通道。在容量未满时，发送操作不会阻塞；在容量未空时，接收操作不会阻塞。
bufferedCh := make(chan int, 2)
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println("[缓冲发送者]：发送 1")
bufferedCh <- 1 // 不会阻塞，通道有空位
fmt.Println("[缓冲发送者]：发送 2")
bufferedCh <- 2 // 不会阻塞，通道仍有空位
fmt.Println("[缓冲发送者]：尝试发送 3 (通道已满，将阻塞直到有接收者)")
bufferedCh <- 3 // 阻塞，因为通道已满
fmt.Println("[缓冲发送者]：3 已发送。")
close(bufferedCh) // 发送完毕，关闭通道
}()
// 给发送goroutine一点时间启动并填充缓冲
time.Sleep(50 * time.Millisecond)
fmt.Println("[缓冲接收者]：准备接收缓冲消息...")
val1 := <-bufferedCh
fmt.Printf("[缓冲接收者]：收到缓冲消息: %d\n", val1)
val2 := <-bufferedCh
fmt.Printf("[缓冲接收者]：收到缓冲消息: %d\n", val2)
// 此时通道有一个空位，发送者goroutine中的 `bufferedCh <- 3` 将不再阻塞，可以继续发送
val3 := <-bufferedCh
fmt.Printf("[缓冲接收者]：收到缓冲消息: %d\n", val3)
// 使用 for-range 循环接收通道中所有剩余的值，直到通道被关闭
fmt.Println("[缓冲接收者]：开始使用 for-range 接收剩余消息...")
for v := range bufferedCh {
fmt.Printf("[缓冲接收者]：通过 for-range 收到: %d\n", v)
}
fmt.Println("[缓冲接收者]：所有缓冲消息接收完毕。")
wg.Wait() // 等待缓冲发送者goroutine完成
fmt.Println("\n---")
// 3. Select 语句与通道超时
// select 允许一个goroutine等待多个通信操作。它会阻塞直到某个case可以执行。
timeoutCh := make(chan string)
doneCh := make(chan bool)
go func() {
time.Sleep(2 * time.Second) // 模拟一个耗时操作
timeoutCh <- "操作完成！"
// close(timeoutCh) // 通常这里不会关闭，因为可能还有其他操作
}()
go func() {
time.Sleep(3 * time.Second) // 模拟一个更耗时，或者说，完成信号
doneCh <- true
}()
fmt.Println("[Select示例]：开始等待操作或超时...")
select {
case res := <-timeoutCh:
fmt.Printf("[Select示例]：收到结果: '%s'\n", res)
case <-time.After(1 * time.Second): // 1秒后超时
fmt.Println("[Select示例]：操作超时了！")
}
// 再次使用select，这次等待done信号
fmt.Println("[Select示例]：等待最终完成信号...")
select {
case res := <-timeoutCh: // 如果之前没收到，这里可能还会收到
fmt.Printf("[Select示例]：再次收到结果: '%s'\n", res)
case <-doneCh:
fmt.Println("[Select示例]：收到完成信号，程序即将退出。")
case <-time.After(5 * time.Second): // 再次设置一个超时，防止死锁
fmt.Println("[Select示例]：等待完成信号超时。")
}
fmt.Println("\n所有示例运行完毕。")
}我个人觉得，Go语言的Channel之所以能成为并发编程的“杀手锏”，核心在于它对“共享内存通过通信”这一理念的彻底贯彻。传统多线程编程中，我们常常为了保护共享数据而绞尽脑汁地使用互斥锁（Mutex）、信号量（Semaphore）等机制。这不仅代码写起来复杂，更可怕的是，一不小心就可能引入死锁、竞态条件等难以调试的bug。每次看到那些复杂的锁机制，我都会感到一种深深的疲惫。
Channel则提供了一种完全不同的思路。它不是让你去“保护”共享数据，而是让你去“传递”数据。数据在goroutine之间流动，每次只有一个goroutine拥有它的所有权，这从根本上避免了数据竞争。你可以把它想象成一个安全的邮筒，你把信（数据）投进去，然后另一个邮递员（goroutine）来取走。这个过程是天然同步的，你不用担心两个邮递员同时抢一封信，也不用担心信件在传递过程中被篡改。
这种设计哲学，让并发代码变得异常清晰和简洁。我们不再需要过多地关注底层同步原语的复杂性，而是可以专注于业务逻辑本身。Channel的阻塞特性，本身就是一种强大的同步机制：无缓冲Channel的发送和接收必须同时就绪，这天然地形成了一个同步点；有缓冲Channel则提供了一种“解耦”的能力，让发送者和接收者不必完全同步，从而提升了系统的吞吐量。它就像是Go语言为并发编程量身定制的“基础设施”，用起来顺手，而且非常可靠。
立即学习“go语言免费学习笔记（深入）”；
Channel的关闭（
close()
<-ch
close(ch)
首先，
close(ch)
panic
int
string
为了安全地接收数据并判断Channel是否已关闭，最推荐的方式是使用
for range
for value := range myChannel {
// 处理接收到的值
}
// 当myChannel被关闭且所有值都已被接收后，循环会自动退出这种方式简洁且安全，它会一直阻塞直到Channel有新值或者被关闭。
另一种常见的安全接收模式是使用多返回值：
value, ok := <-myChannel
if !ok {
// Channel已关闭，并且所有值都已接收完毕
fmt.Println("Channel已关闭")
return
}
// 正常处理接收到的值这里的
ok
ok
false
关于关闭Channel，有一个非常重要的原则：通常由发送者关闭Channel，而不是接收者。这是因为发送者知道何时没有更多的数据需要发送。如果接收者关闭Channel，可能会在发送者仍然尝试发送数据时引发
panic
panic
sync.WaitGroup
done
Channel不仅仅是用来传递几个简单的值，它在构建复杂的并发系统时，简直是Go语言提供的一把瑞士军刀。我个人在项目实践中，经常会用到以下几种模式，它们能大大提升代码的健壮性和可维护性：
工作池（Worker Pool）模式： 想象一下，你有一堆任务需要处理，但又不想启动过多的goroutine导致资源耗尽。这时候，Channel就能派上用场。你可以创建一个任务Channel，让多个工作goroutine从这个Channel中接收任务并执行。当所有任务都发送到Channel后，关闭任务Channel，工作goroutine就会在处理完所有任务后优雅地退出。这就像一个工厂，流水线上不断有产品（任务）过来，工人们（goroutine）各自去取产品加工。
// 概念示例
tasks := make(chan int, 100)
results := make(chan int, 100)
// 启动3个worker
for i := 0; i < 3; i++ {
go func() {
for task := range tasks {
// 处理任务...
results <- task * 2 // 将结果发送到结果Channel
}
}()
}
// 发送任务
for i := 0; i < 10; i++ {
tasks <- i
}
close(tasks) // 所有任务发送完毕
// 接收结果 (这里需要一个机制来知道何时所有结果都已处理)
// ...扇入/扇出（Fan-in/Fan-out）模式： 当你有多个数据源需要合并到一个Channel（扇入），或者一个数据源需要分发给多个处理者（扇出）时，Channel提供了非常直观的解决方案。扇出通常很简单，多个goroutine同时从一个Channel接收数据即可。扇入则需要一个聚合器，它从多个输入Channel接收数据，然后发送到一个统一的输出Channel。这在数据处理管道中非常常见，比如从多个API拉取数据，然后统一处理。
超时与取消（Timeout and Cancellation）：
select
time.After
context.Done()
select
// 概念示例：结合Context实现取消
ctx, cancel := context.WithCancel(context.Background())
dataCh := make(chan string)
go func(ctx context.Context) {
select {
case <-time.After(5 * time.Second):
dataCh <- "数据已生成"
case <-ctx.Done():
fmt.Println("操作被取消")
return
}
}(ctx)
// 模拟在某个时刻取消操作
go func() {
time.Sleep(2 * time.Second)
cancel() // 取消操作
}()
select {
case data := <-dataCh:
fmt.Println("接收到数据:", data)
case <-ctx.Done():
fmt.Println("主goroutine检测到操作被取消")
}请求-响应（Request-Response）模式： 有时一个goroutine需要向另一个goroutine发送一个请求，并等待其响应。虽然直接传递数据Channel可以实现，但更优雅的方式是在请求中嵌入一个临时的响应Channel。
type Request struct {
data string
respCh chan string // 用于接收响应的Channel
}
reqCh := make(chan Request)
go func() { // 处理器goroutine
for req := range reqCh {
// 处理请求...
req.respCh <- "处理结果：" + req.data // 将结果发送回请求者
}
}()
// 请求者goroutine
respCh := make(chan string)
reqCh <- Request{data: "我的请求", respCh: respCh}
response := <-respCh
fmt.Println(response)这些模式只是冰山一角。Channel的灵活性和Go语言的并发原语结合，可以构建出几乎任何你想要的并发模型。关键在于理解其核心原理，并善用Go提供的工具。
以上就是Golang channel创建与通信完整示例的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
804
收藏
