执行方法时内存消耗较大

从现在开始，我们要努力学习啦！今天我给大家带来《执行方法时内存消耗较大》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

对于一个项目，我想为 csv 的大约 5000 万行中的每一行手动创建结构。为此，我逐行迭代文件并将每个结构附加到一个切片。这是简化的方法：

func readcsv(filepath string) dataframe {
    file, _ := os.open(filepath)
    defer file.close()
    var rows []row
    scanner := bufio.newscanner(file)
    scanner.scan()
    for scanner.scan() {
        parts := strings.split(scanner.text(), ",")
        if len(parts) < 7 {
            continue
        }
        column1, _ := strconv.atoi(parts[0])
        column2, _ := strconv.parsefloat(parts[1], 32)
        column3, _ := strconv.parsefloat(parts[2], 32)
        column4 := parts[3]
        column5, _ := strconv.parsefloat(parts[4], 32)
        column6 := parts[5]
        column7 := parts[6]
        row := row{
            column1: column1,
            column2: column2,
            column3: column3,
            column4: column4,
            column5: column5,
            column6: column6,
            column7: column7,
        }
        rows = append(rows, row)
    }
    return dataframe{
        rows: rows,
    }
}

生成的 dataframe 大约有 3 gb 内存。问题是在方法执行期间 ram 消耗急剧增加，并且 go 进程使用 15gb 以上的内存，使得该函数无法用于我的目的。一旦切片返回，进程的 ram 消耗就会下降到预期的 3gb。

堆配置文件如下所示：

3.26GB     5.81GB (flat, cum)   100% of Total
         .          .     62:   scanner := bufio.NewScanner(file)
         .          .     63:   scanner.Scan()
         .          .     64:   for scanner.Scan() {
         .     2.55GB     65:           parts := strings.Split(scanner.Text(), ",")
         .          .     66:           if len(parts) < 7 {
         .          .     67:                   continue
         .          .     68:           }
         .          .     69:           column1, _ := strconv.Atoi(parts[0])
         .          .     70:           column2, _ := strconv.ParseFloat(parts[1], 32)
         .          .     71:           column3, _ := strconv.ParseFloat(parts[2], 32)
         .          .     72:           column4 := parts[3]
         .          .     73:           column5, _ := strconv.ParseFloat(parts[4], 32)
         .          .     74:           column6 := parts[5]
         .          .     75:           column7 := parts[6]
         .          .     76:           row := Row{
         .          .     77:                   Column1: column1,
         .          .     78:                   Column2: column2,
         .          .     79:                   Column3: column3,
         .          .     80:                   Column4: column4,
         .          .     81:                   Column5: column5,
         .          .     82:                   Column6: column6,
         .          .     83:                   Column7: column7,
         .          .     84:           }
    3.26GB     3.26GB     85:           rows = append(rows, row)
         .          .     86:   }
         .          .     87:
         .          .     88:   return DataFrame{
         .          .     89:           Rows: rows,

我不知道高内存消耗从何而来。我尝试手动调用垃圾收集器但没有成功。谁能给我提示吗？

解决方案

rows 是 row 结构体数组，而不是指针。每行浮点数和整数占用 32 个字节，加上字符串的长度。 5000 万行可能会变得相当大。更糟糕的是，append 将使 rows 增长约 1.5 倍，因此它最终会分配大量额外内存，同时还会丢弃许多需要垃圾收集的较小版本。然后 append(rows, row) 是一个副本，意味着更多的分配和释放。而且它必须等待被垃圾收集，从而导致内存使用量膨胀。

可以通过存储引用来避免这种情况。这应该意味着更少的分配，并使 rows 显着更小。

var rows []*row
...
rows = append(rows, &row)

然而，真正的问题是一次性吞掉所有东西。这就是走吧！我们可以使用 channels 和 goroutines 在我们的处理过程中一次同时读取一行。

csv 看似棘手。 go 已经有一个 csv 库 encoding/csv，所以我们将使用它。

# A handy function to make ignoring errors a bit less laborious.
func IgnoreError(value interface{}, err error) interface{} {
    return value
}

# Its more flexible to take an io.Reader.
# It returns a channel of individual rows.
func readCSV(input io.Reader) chan Row {
    rows := make(chan Row)
    go func() {
        defer close(rows)

        # Use encoding/csv.
        # Let it reuse its backing array for each row.
        # Ignore rows with the wrong number of columns.
        reader := csv.NewReader(input)
        reader.FieldsPerRecord = 7
        reader.ReuseRecord = true

        for {
            parts, err := reader.Read()

            if err == io.EOF {
                break
            }
            if err != nil {
                continue
            }

            # Send each row down the channel.
            rows <- Row{
                Column1: IgnoreError(strconv.Atoi(parts[0])).(int),
                Column2: IgnoreError(strconv.ParseFloat(parts[1], 32)).(float64),
                Column3: IgnoreError(strconv.ParseFloat(parts[2], 32)).(float64),
                Column4: parts[3],
                Column5: IgnoreError(strconv.ParseFloat(parts[4], 32)).(float64),
                Column6: parts[5],
                Column7: parts[6],
            }
        }
    }();
    
    return rows;
}

func main() {
    file, err := os.Open("test.csv")
    if err != nil {
        log.Fatal(err)
    }
    
    rows := readCSV(file)
    for row := range rows {
        fmt.Println(row)
    }
}

现在一次仅加载一行。内存使用量应该是恒定的。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《执行方法时内存消耗较大》文章吧，也可关注golang学习网公众号了解相关技术文章。