Golang中行扫描内存占用过高且无法完成处理的问题

根据你提供的代码分析，内存占用过高的问题主要出现在以下几个方面：

1. 未关闭数据库连接和结果集

每次查询后没有及时关闭 rows，导致连接和内存泄漏。

2. 大量重复查询

在循环中对相同数据反复查询，应该考虑批量处理或缓存结果。

3. 行扫描的内存分配

每次扫描都创建新的变量，没有复用内存。

修复后的代码示例：

package main

import (
    "database/sql"
    "fmt"
    "log"
    "time"
    _ "github.com/lib/pq"
)

func processData(db *sql.DB) error {
    // 查询主数据
    rows, err := db.Query(`
        SELECT id, name, status 
        FROM users 
        WHERE status = 'active' 
        LIMIT 1000`)
    if err != nil {
        return err
    }
    defer rows.Close()

    // 批量处理，避免N+1查询问题
    var userIDs []int64
    for rows.Next() {
        var id int64
        var name string
        var status string
        
        if err := rows.Scan(&id, &name, &status); err != nil {
            log.Printf("扫描错误: %v", err)
            continue
        }
        userIDs = append(userIDs, id)
    }

    if err = rows.Err(); err != nil {
        return err
    }

    // 批量查询详细信息，避免循环中的单独查询
    if len(userIDs) > 0 {
        query := `
            SELECT user_id, detail 
            FROM user_details 
            WHERE user_id = ANY($1)`
        
        detailRows, err := db.Query(query, userIDs)
        if err != nil {
            return err
        }
        defer detailRows.Close()

        for detailRows.Next() {
            var userID int64
            var detail string
            if err := detailRows.Scan(&userID, &detail); err != nil {
                log.Printf("扫描详情错误: %v", err)
                continue
            }
            // 处理详情数据
            _ = userID
            _ = detail
        }
    }

    return nil
}

func main() {
    db, err := sql.Open("postgres", "your-connection-string")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 设置连接池参数
    db.SetMaxOpenConns(10)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(time.Hour)

    // 限制处理次数
    maxIterations := 5
    ticker := time.NewTicker(30 * time.Second)
    defer ticker.Stop()

    iteration := 0
    for range ticker.C {
        if iteration >= maxIterations {
            break
        }

        if err := processData(db); err != nil {
            log.Printf("处理数据错误: %v", err)
        }
        
        iteration++
        fmt.Printf("完成迭代 %d\n", iteration)
    }
}

关键优化点：

1. 使用 defer rows.Close()：确保结果集被正确关闭
2. 批量查询：避免在循环中执行单独查询（N+1问题）
3. 连接池配置：合理设置数据库连接池参数
4. 限制结果集：使用 LIMIT 控制每次处理的数据量
5. 错误处理：正确处理扫描和查询错误

内存监控建议：

// 添加内存监控
import "runtime"

func printMemoryUsage() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("内存使用: Alloc = %v MiB, TotalAlloc = %v MiB, Sys = %v MiB\n",
        m.Alloc/1024/1024, m.TotalAlloc/1024/1024, m.Sys/1024/1024)
}

在 processData 函数前后调用 printMemoryUsage() 可以监控内存变化。