Golang中如何绕过最大并发连接数的限制

你的代码存在并发设计问题。wg.Wait() 放在了循环内部，导致每次迭代都会等待所有 goroutine 完成，实际上变成了串行执行。更严重的是，对于大文件中每个以 “5” 开头的 ST_ID，你都会启动一个 goroutine 来遍历整个 salesTrx 切片，这会导致创建大量 goroutine。

以下是优化方案：

func NetTrx(item string, allTrx *[]models.MainModel, salesTrx *[]models.SalesTransactions) []models.NetTrasActions {
    // 创建销售交易的查找映射，避免线性搜索
    salesMap := make(map[string]map[string]float64) // ST_ID -> ITEM_ID -> CURNT_COST_L
    
    for _, s := range *salesTrx {
        if _, exists := salesMap[s.ST_ID]; !exists {
            salesMap[s.ST_ID] = make(map[string]float64)
        }
        salesMap[s.ST_ID][s.ITEM_ID] = s.CURNT_COST_L
    }
    
    var result []models.NetTrasActions
    var mu sync.Mutex
    var wg sync.WaitGroup
    
    // 控制并发goroutine数量
    sem := make(chan struct{}, 1000) // 限制最大1000个并发
    
    for _, v := range *allTrx {
        trx := models.NetTrasActions{
            ST_TYPE:      v.ST_TP,
            ITEM_ID:      v.ITEM_ID,
            ITEM_NAME:    v.ITEM_NAME,
            QTY:          v.QTY,
            CURNT_COST_L: 0,
            PRICE:        v.PRICE,
            TTL_VAL:      v.QTY * v.PRICE,
            TTL_CST:      0,
            SLS_CNTR_ID:  v.SLS_CNTR_ID,
            BARCODE:      v.BARCODE,
        }
        
        if strings.HasPrefix(v.ST_ID, "5") {
            wg.Add(1)
            sem <- struct{}{} // 获取信号量
            
            go func(v models.MainModel, trx models.NetTrasActions) {
                defer wg.Done()
                defer func() { <-sem }() // 释放信号量
                
                if itemMap, exists := salesMap[v.ST_ID]; exists {
                    if cost, found := itemMap[v.ITEM_ID]; found {
                        trx.CURNT_COST_L = cost
                    }
                }
                
                mu.Lock()
                result = append(result, trx)
                mu.Unlock()
            }(v, trx)
        } else {
            // 非销售交易直接添加到结果
            mu.Lock()
            result = append(result, trx)
            mu.Unlock()
        }
    }
    
    wg.Wait()
    return result
}

更高效的批处理版本：

func NetTrxBatch(allTrx *[]models.MainModel, salesTrx *[]models.SalesTransactions) []models.NetTrasActions {
    // 构建查找映射
    salesMap := make(map[string]map[string]float64)
    for _, s := range *salesTrx {
        if _, exists := salesMap[s.ST_ID]; !exists {
            salesMap[s.ST_ID] = make(map[string]float64)
        }
        salesMap[s.ST_ID][s.ITEM_ID] = s.CURNT_COST_L
    }
    
    result := make([]models.NetTrasActions, len(*allTrx))
    
    // 使用工作池处理
    numWorkers := runtime.NumCPU() * 2
    chunkSize := len(*allTrx) / numWorkers
    
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        start := i * chunkSize
        end := start + chunkSize
        if i == numWorkers-1 {
            end = len(*allTrx)
        }
        
        go func(start, end int) {
            defer wg.Done()
            for j := start; j < end; j++ {
                v := (*allTrx)[j]
                trx := models.NetTrasActions{
                    ST_TYPE:      v.ST_TP,
                    ITEM_ID:      v.ITEM_ID,
                    ITEM_NAME:    v.ITEM_NAME,
                    QTY:          v.QTY,
                    CURNT_COST_L: 0,
                    PRICE:        v.PRICE,
                    TTL_VAL:      v.QTY * v.PRICE,
                    TTL_CST:      0,
                    SLS_CNTR_ID:  v.SLS_CNTR_ID,
                    BARCODE:      v.BARCODE,
                }
                
                if strings.HasPrefix(v.ST_ID, "5") {
                    if itemMap, exists := salesMap[v.ST_ID]; exists {
                        if cost, found := itemMap[v.ITEM_ID]; found {
                            trx.CURNT_COST_L = cost
                        }
                    }
                }
                result[j] = trx
            }
        }(start, end)
    }
    
    wg.Wait()
    return result
}

关键优化点：

1. 使用映射（map）替代线性搜索，将 O(n²) 复杂度降为 O(n)
2. 使用信号量或工作池控制并发数量
3. 避免为每个匹配都创建 goroutine
4. 使用批处理减少 goroutine 创建开销