为何同一结构体的Go通道间调度写入后目标通道未被消费？

核心问题分析 #

你的代码里group2的消息无法被消费，主要是两个原因导致：

1. 无缓冲通道的阻塞陷阱
   你创建的group2是无缓冲通道（make(chan []byte)），无缓冲通道的发送操作必须等到有接收者就绪才能完成。当Run函数的goroutine处理group1的消息后，执行r.group2 <- []byte("hello from group 2")时，此时没有任何其他goroutine在等待接收group2的数据，这个发送操作会直接阻塞当前的Run goroutine。而goroutine被阻塞后，就无法回到select循环去处理group2的接收分支，相当于卡死在发送步骤。

2. main goroutine提前终止
   main函数发送完group1的消息后，没有任何等待逻辑就直接退出。Go程序中，main goroutine退出会导致整个程序立即终止，所有其他goroutine（包括运行Run的那个）都会被强制停止，就算后续有机会处理group2的消息，也没有执行的时间窗口。

修复方案 #

方案一：给通道添加缓冲

给group2设置缓冲大小，让发送操作不会阻塞，这样Run goroutine可以回到select循环处理后续的接收操作，同时在main函数里添加等待逻辑，确保消息被处理完成：

package main

import (
    "fmt"
    "time"
)

type Runner struct {
    group1 chan []byte
    group2 chan []byte
}

func (r *Runner) Run() {
    for {
        select {
        case info := <-r.group1:
            fmt.Printf("%s\n", info)
            r.group2 <- []byte("hello from group 2")
        case info2 := <-r.group2:
            fmt.Printf("%s\n", info2)
        }
    }
}

func newRunner() *Runner {
    return &Runner{
        group1: make(chan []byte),
        group2: make(chan []byte, 1), // 给group2添加1个缓冲
    }
}

func main() {
    runner := newRunner()
    go runner.Run()
    runner.group1 <- []byte("hello from group 1")
    
    time.Sleep(time.Second) // 等待消息处理完成
}

方案二：用独立goroutine处理每个通道

把group1和group2的消费逻辑拆分到不同的goroutine中，避免同一goroutine内发送和接收导致的阻塞，同时用sync.WaitGroup等待所有goroutine完成：

package main

import (
    "fmt"
    "sync"
)

type Runner struct {
    group1 chan []byte
    group2 chan []byte
    wg     sync.WaitGroup
}

func (r *Runner) Run() {
    r.wg.Add(2)
    // 单独goroutine处理group1
    go func() {
        defer r.wg.Done()
        for info := range r.group1 {
            fmt.Printf("%s\n", info)
            r.group2 <- []byte("hello from group 2")
        }
        close(r.group2) // 处理完group1后关闭group2
    }()
    // 单独goroutine处理group2
    go func() {
        defer r.wg.Done()
        for info2 := range r.group2 {
            fmt.Printf("%s\n", info2)
        }
    }()
    r.wg.Wait()
}

func newRunner() *Runner {
    return &Runner{
        group1: make(chan []byte),
        group2: make(chan []byte),
    }
}

func main() {
    runner := newRunner()
    go runner.Run()
    runner.group1 <- []byte("hello from group 1")
    
    close(runner.group1) // 关闭group1触发goroutine结束
    runner.wg.Wait()
}

内容的提问来源于stack exchange，提问作者Jhonatan Morais