Golang中如何实现多协程的超时控制

除了 @skillian 的解决方案，如果 goroutine 包含一个长时间运行的循环，你也可以在循环内部通过 select 语句检查上下文的“done”通道来寻找超时。

func call_first(ctx context.Context, call_status chan bool, info Info) {
    ... 
    /* 长时间运行的循环 */
    for /* 某个条件 */ {
        select {
        case <-ctx.Done():
            fmt.Println(ctx.Err()) // 以某种方式处理错误
            return // 返回，或者也可以跳出循环
        default: // 需要此分支，以使 select 语句不会阻塞
        }
        /* 尚未超时或出错 -> 进行一些处理 */
    }
    call_status <- true
}

在Go中实现多协程的超时控制，需要正确使用context的取消机制。你的代码存在几个关键问题：

1. context没有传递给goroutine使用：你的goroutine函数签名显示接收context，但实际调用时没有传递
2. goroutine没有检查context状态：即使传递了context，也需要在goroutine内部检查ctx.Done()
3. channel使用不当：call_status channel应该能传递错误信息

以下是修正后的实现：

func GetResponse() ([]Result, error) {
    ctx, cancel := context.WithTimeout(context.Background(), time.Duration(searchData.TimeOut)*time.Second)
    defer cancel()
    
    InfoList := info.GetList()
    count := len(InfoList)
    
    // 使用带缓冲的channel，避免goroutine泄漏
    results := make(chan Result, count*4)
    errCh := make(chan error, 1)
    
    // 启动所有goroutine
    for _, info := range InfoList {
        go info.call_first(ctx, info, results, errCh)
        go info.call_second(ctx, info, results, errCh)
        go info.call_third(ctx, info, results, errCh)
        go info.call_n(ctx, info, results, errCh)
    }
    
    // 收集结果，直到超时或所有goroutine完成
    var collectedResults []Result
    for i := 0; i < count*4; i++ {
        select {
        case <-ctx.Done():
            // 超时发生，返回已收集的结果
            return collectedResults, ctx.Err()
        case result := <-results:
            collectedResults = append(collectedResults, result)
        case err := <-errCh:
            // 发生错误，立即返回
            return collectedResults, err
        }
    }
    
    return collectedResults, nil
}

goroutine函数需要这样实现：

func (i *Info) call_first(ctx context.Context, info Info, results chan<- Result, errCh chan<- error) {
    // 创建一个带取消的context，确保不会阻塞
    done := make(chan struct{})
    
    go func() {
        defer close(done)
        // 模拟耗时操作
        time.Sleep(5 * time.Second)
        
        select {
        case <-ctx.Done():
            return // 超时了，直接返回
        default:
            // 正常处理逻辑
            result := process(info)
            select {
            case results <- result:
            case <-ctx.Done():
                return
            }
        }
    }()
    
    select {
    case <-ctx.Done():
        // 超时发生
        return
    case <-done:
        // 正常完成
        return
    }
}

或者更简洁的实现方式：

func (i *Info) call_first(ctx context.Context, info Info, results chan<- Result, errCh chan<- error) {
    // 使用select监听context取消
    select {
    case <-ctx.Done():
        return // 超时或取消
    default:
        // 继续执行
    }
    
    // 执行实际工作
    result, err := doWork(info)
    if err != nil {
        select {
        case errCh <- err:
        case <-ctx.Done():
        }
        return
    }
    
    // 发送结果，同时监听context
    select {
    case results <- result:
    case <-ctx.Done():
        // 超时了，丢弃结果
    }
}

对于需要强制停止长时间运行操作的情况，可以使用context.WithCancel：

func GetResponseWithForceStop() ([]Result, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()
    
    // 使用sync.WaitGroup跟踪goroutine
    var wg sync.WaitGroup
    results := make(chan Result, 100)
    
    for _, info := range InfoList {
        wg.Add(4)
        
        go func(info Info) {
            defer wg.Done()
            if err := doWorkWithContext(ctx, info); err != nil {
                // 处理错误
                return
            }
            // 发送结果
            select {
            case results <- result:
            case <-ctx.Done():
            }
        }(info)
        
        // 其他goroutine类似...
    }
    
    // 等待所有goroutine完成或超时
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // 收集结果
    var collected []Result
    for {
        select {
        case <-ctx.Done():
            return collected, ctx.Err()
        case result, ok := <-results:
            if !ok {
                return collected, nil
            }
            collected = append(collected, result)
        }
    }
}

关键点：

1. 每个goroutine必须定期检查ctx.Done()通道
2. 所有阻塞操作都应该支持context取消
3. 使用select语句同时监听结果和context状态
4. 确保channel有足够的缓冲区或使用非阻塞发送