Golang中如何解决goroutine无法从channel读取数据的问题

这是一个典型的goroutine调度和channel通信时序问题。问题根源在于goroutine的启动和调度时机。

当fib(30)计算量较大时，主goroutine会长时间阻塞在计算中，此时第一个fn goroutine已经启动并进入了select循环。但由于主goroutine尚未执行到ch <- i，第一个fn goroutine会在select中等待。

当主goroutine完成计算并发送数据到channel时，第一个fn goroutine可能正在执行select的某个case（很可能是timer case），导致错过了channel的接收。

以下是解决方案：

package main

import (
	"time"
	"fmt"
	"sync"
)

var ch chan int
var ptimer map[string]*time.Timer
var m map[string]int
var startTime int64
var mu sync.Mutex

func fn(name string, i int, wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("this my name:", name)
	flag := false
	
	// 确保在进入select循环前channel已准备好
	mu.Lock()
	if ch == nil {
		ch = make(chan int, 1)
	}
	mu.Unlock()
	
	for {
		endTime := time.Now().UnixNano()
		fmt.Println("	in for duration:", float64((endTime-startTime)))
		select {
		case tmp := <-ch:
			fmt.Println("	this is ch, tmp:", tmp)
			flag = true
		case <-ptimer[name].C:
			_, ok := m[name]
			if !ok {
				fmt.Println("	", name, "not in m")
				flag = true
			}
			if 1 == 1 {
				fmt.Println("	this is in 1==1!!!!!!!!!!!!!!!!!!!!")
				ptimer[name].Reset(time.Second * 20)
			}
		}
		if flag {
			fmt.Println("	in flag == true no.:", i, "\n")
			break
		}
	}
}

func fib(a int) int {
	if a == 0 {
		return 0
	} else if a == 1 {
		return 1
	} else {
		return fib(a-1) + fib(a-2)
	}
}

func main() {
	fmt.Println("this is in main")
	name := "hello"
	m = make(map[string]int)
	ptimer = make(map[string]*time.Timer)
	startTime = time.Now().UnixNano()

	// 提前初始化channel
	ch = make(chan int, 1)
	
	var wg sync.WaitGroup
	i := 1
	for {
		m[name] = 30
		ptimer[name] = time.NewTimer(time.Second * 20)
		
		wg.Add(1)
		go fn(name, i, &wg)
		
		// 立即发送数据到channel
		ch <- i
		fmt.Println("after send exit_overtime\n")
		
		fmt.Println("fib:", fib(m[name]))
		endTime := time.Now().UnixNano()
		fmt.Println("duration:", float64((endTime-startTime)))
		
		delete(m, name)
		i++
		
		// 等待goroutine完成
		wg.Wait()
		time.Sleep(time.Second)
		
		// 重置channel用于下一次循环
		ch = make(chan int, 1)
	}
}

或者使用带缓冲的channel和同步机制：

package main

import (
	"time"
	"fmt"
	"context"
)

var ch chan int
var ptimer map[string]*time.Timer
var m map[string]int
var startTime int64

func fn(name string, i int, ctx context.Context) {
	fmt.Println("this my name:", name)
	flag := false
	for {
		select {
		case <-ctx.Done():
			fmt.Println("	context cancelled, exiting")
			return
		case tmp := <-ch:
			fmt.Println("	this is ch, tmp:", tmp)
			flag = true
		case <-ptimer[name].C:
			_, ok := m[name]
			if !ok {
				fmt.Println("	", name, "not in m")
				flag = true
			}
			if 1 == 1 {
				fmt.Println("	this is in 1==1!!!!!!!!!!!!!!!!!!!!")
				ptimer[name].Reset(time.Second * 20)
			}
		}
		if flag {
			fmt.Println("	in flag == true no.:", i, "\n")
			break
		}
	}
}

func fib(a int) int {
	if a == 0 {
		return 0
	} else if a == 1 {
		return 1
	} else {
		return fib(a-1) + fib(a-2)
	}
}

func main() {
	fmt.Println("this is in main")
	name := "hello"
	m = make(map[string]int)
	ptimer = make(map[string]*time.Timer)
	startTime = time.Now().UnixNano()

	// 使用带缓冲的channel
	ch = make(chan int, 10)
	
	i := 1
	for {
		m[name] = 30
		ptimer[name] = time.NewTimer(time.Second * 20)
		
		// 创建context用于控制goroutine生命周期
		ctx, cancel := context.WithCancel(context.Background())
		
		// 先发送数据到channel
		ch <- i
		
		// 再启动goroutine
		go fn(name, i, ctx)
		
		fmt.Println("after send exit_overtime\n")
		
		fmt.Println("fib:", fib(m[name]))
		endTime := time.Now().UnixNano()
		fmt.Println("duration:", float64((endTime-startTime)))
		
		delete(m, name)
		i++
		
		// 取消context确保goroutine退出
		cancel()
		time.Sleep(time.Second)
	}
}

关键点：

1. 在启动goroutine前先初始化channel
2. 使用带缓冲的channel确保数据不会丢失
3. 使用同步机制（WaitGroup或Context）控制goroutine生命周期
4. 确保发送操作在goroutine开始监听前执行

这样无论fib函数执行时间多长，第一个fn goroutine都能正确接收到channel的数据。