在 Go 语言并发编程里，Goroutine 之间通过 channel 通信是基本范式。但 channel 本身每次只能传递一个元素，当某个后台任务需要同时返回多个结果，例如计算结果加错误信息，初学者常会尝试用 chan int, error 这类写法，编译器会直接拒绝。要解决这个问题，本质上只有两条路：要么把多个返回值打包成一个复合类型再发送，要么借助语言层面的多赋值语法配合特定通道设计来模拟多返回值效果。下面先建立直观认识。
使用结构体封装多返回值并通过通道传递
最直观也最推荐的方式，是定义一个结构体，把 Goroutine 需要返回的所有字段都作为它的成员。发送端在任务完成后构造该结构体实例并写入通道，接收端从通道读出后按字段名访问。这种方式的优势在于类型清晰，IDE 可以自动补全，且后续增加返回字段时只需修改结构体定义，不会破坏已有接收逻辑。
例如我们有一个并发计算平方与立方的任务，同时可能返回错误。可以定义 Result 结构体包含 sq、cb 与 err。在 Goroutine 中计算完毕后将其实例发送至 chan Result。主函数通过 res := <-ch 获取完整结果。下面是一段可运行示例：
package main
import (
"errors"
"fmt"
)
type Result struct {
sq int
cb int
err error
}
func worker(n int, ch chan Result) {
if n < 0 {
ch <- Result{err: errors.New("negative input")}
return
}
ch <- Result{sq: n * n, cb: n * n * n}
}
func main() {
ch := make(chan Result, 1)
go worker(3, ch)
res := <-ch
if res.err != nil {
fmt.Println("error:", res.err)
return
}
fmt.Printf("sq=%d cb=%dn", res.sq, res.cb)
}
上述代码使用了缓冲通道大小为 1，避免 Goroutine 泄露。如果改为无缓冲通道，必须保证接收方先准备好或另起接收 Goroutine。结构体方案在字段较多时尤其合适，比如同时返回状态码、耗时、数据分片，都比散落多个通道更容易维护。缺点是每次发送都会拷贝整个结构体，如果结构体很大且发送频繁，会带来一定内存开销，此时可改为传递结构体指针 *Result 来减少拷贝。
利用多接收者语法与匿名结构体模拟多返回值
Go 语言支持从通道接收时直接多赋值，例如 a, b := <-ch1, <-ch2，但这要求使用两个通道。若坚持只用一条通道又想要“多返回值”的书写感，可以把匿名结构体作为元素类型，在接收时配合短变量声明拆解。虽然底层仍是单元素传递，但语法上接近函数返回多个值。
另一种变体是使用 chan [2]int 这类数组通道，发送端写数组，接收端用 v1, v2 := (<-ch)[0], (<-ch)[1] 取用。不过这种写法可读性差，且无法携带错误。更实用的模拟方案是定义带错误字段的匿名结构体并立即解构：
package main
import (
"fmt"
)
func worker(ch chan struct {
a int
b int
}) {
ch <- struct {
a int
b int
}{a: 10, b: 20}
}
func main() {
ch := make(chan struct {
a int
b int
})
go worker(ch)
r := <-ch
fmt.Println(r.a, r.b)
}
这段代码在通道类型里直接写了匿名结构体，发送和接收都不必事先命名类型。适合一次性、临时的轻量任务。但匿名结构体不能跨包复用，也不方便添加方法，当逻辑变复杂时维护成本上升。相比具名结构体方案，它省去了类型定义行，却牺牲了清晰度和扩展性。在团队项目中，通常建议仅在小工具或测试代码里这样写。
错误传递与关闭通道的最佳实践
无论采用哪种封装方式，Goroutine 中的错误都必须显式传回，而不能仅靠 panic。结构体方案天然可用错误字段；若用多通道模拟，则建议单独开一个 chan error 由接收方用 select 监听。另外，通道关闭应由发送方在不再写入时调用 close，接收方通过逗号 ok 模式判断通道是否关闭，防止死锁。
当多个 Goroutine 向同一通道发送封装结果时，可用 sync.WaitGroup 等待全部完成再由管理 Goroutine 关闭通道。下面示例展示带错误字段的结构体配合 WaitGroup 的安全模式：
package main
import (
"errors"
"fmt"
"sync"
)
type Out struct {
val int
err error
}
func main() {
ch := make(chan Out, 3)
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
if id == 2 {
ch <- Out{err: errors.New("fail")}
return
}
ch <- Out{val: id * id}
}(i)
}
go func() {
wg.Wait()
close(ch)
}()
for o := range ch {
if o.err != nil {
fmt.Println("err:", o.err)
continue
}
fmt.Println("val:", o.val)
}
}
该模式确保通道被正确关闭，主循环通过 range 自然退出。对比可知，结构体封装在错误传递、多任务汇聚时优势明显；而匿名结构体或数组通道仅适用于极简场景。理解这两种实现方式的差异，能让你在 Golang 并发设计中做出更合理的抽象，减少通道使用不当引发的 bug 与性能问题。