如何手动释放高丽内存

Question

下面是计算C(36,8)并将结果保存到文件的代码

func combine_dfs(n int, k int) (ans [][]int) {
    temp := []int{}
    var dfs func(int)
    dfs = func(cur int) {
        if len(temp)+(n-cur+1) < k {
            return
        }
        if len(temp) == k {
            comb := make([]int, k)
            copy(comb, temp)
            ans = append(ans, comb)
            return
        }
        temp = append(temp, cur)
        dfs(cur + 1)
        temp = temp[:len(temp)-1]
        dfs(cur + 1)
    }
    dfs(1)
    return
}

func DoCombin() {
    fmt.Printf("%v\n", "calculator...")
    cst := []byte{}
    for i := 'a'; i <= 'z'; i++ {
        cst = append(cst, byte(i))
    }
    for i := '0'; i <= '9'; i++ {
        cst = append(cst, byte(i))
    }
    n := 36
    k := 8
    arr := combine_dfs(n, k)
    fmt.Printf("%v\n", "writefile...")
    file, _ := os.OpenFile("result.txt", os.O_CREATE|os.O_TRUNC|os.O_RDWR|os.O_APPEND, 0666)
    defer file.Close()
    for _, m := range arr {
        b:= bytes.Buffer{}
        b.Reset()
        for _, i := range m {
            b.WriteByte(cst[i-1])
        }
        b.WriteByte('\n')
        file.Write(b.Bytes())
    }
}

但我写文件太慢了..。

因此，我希望使用goroutine来编写文件(使用池来限制goroutine的数量)：

func DoCombin2() {
    fmt.Printf("%v\n", "calculator...")
    cst := []byte{}
    for i := 'a'; i <= 'z'; i++ {
        cst = append(cst, byte(i))
    }
    for i := '0'; i <= '9'; i++ {
        cst = append(cst, byte(i))
    }
    n := 36
    k := 8
    arr := combine_dfs(n, k)
    fmt.Printf("%v\n", "writefile...")
    file, _ := os.OpenFile("result.txt", os.O_CREATE|os.O_TRUNC|os.O_RDWR|os.O_APPEND, 0666)
    defer file.Close()
    pool := make(chan int, 100)
    for _, m := range arr {
        go func(m []int) {
            pool <- 1
            b := bytes.Buffer{}
            b.Reset()
            for _, i := range m {
                b.WriteByte(cst[i-1])
            }
            b.WriteByte('\n')
            file.Write(b.Bytes())
            <-pool
        }(m)
    }
}

但是记忆爆炸了

我尝试使用sync.Pool来避免它，但是它失败了：

var bufPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func DoCombin() {
    fmt.Printf("%v\n", "calculator...")
    cst := []byte{}
    for i := 'a'; i <= 'z'; i++ {
        cst = append(cst, byte(i))
    }
    for i := '0'; i <= '9'; i++ {
        cst = append(cst, byte(i))
    }
    n := 36
    k := 8
    arr := combine_dfs(n, k)
    fmt.Printf("%v\n", "writefile...")
    file, _ := os.OpenFile("result.txt", os.O_CREATE|os.O_TRUNC|os.O_RDWR|os.O_APPEND, 0666)
    defer file.Close()
    pool := make(chan int, 100)
    for _, m := range arr {
        go func(m []int) {
            pool <- 1
            b, _ := bufPool.Get().(*bytes.Buffer)
            b.Reset()
            for _, i := range m {
                b.WriteByte(cst[i-1])
            }
            b.WriteByte('\n')
            bufPool.Put(b)
            file.Write(b.Bytes())
            <-pool
        }(m)
    }
}

有没有办法避免记忆爆炸？

• 1.为什么我不能在使用sync.Pool之后避免它？
• 2.有什么办法限制windows(我知道的linux中)内存的使用吗？
• 3.是否有其他方法可以避免记忆爆炸？
• 4.内存爆炸是由于bytes.Buffer造成的吗？如何手动释放bytes.Buffer？

Answer 1

根据这个建议: arena:提供内存竞技场的新包

我们建议在Go标准库中添加一个新的arena包。竞技场一揽子方案将允许分配任意数量的竞技场。可以从竞技场的内存中分配任意类型的对象，并根据需要自动增大竞技场的大小。当竞技场中的所有对象不再使用时，可以显式释放竞技场以有效地回收其内存，而无需一般的垃圾收集。我们要求实现提供安全检查，这样，如果没有竞技场的操作是不安全的，程序将在任何不正确的行为发生之前被终止。

这个特性已经合并到竞技场下的主分支，也许可以在go 1.20中发布。使用arena包，您可以自己分配内存，并在不再使用时手动释放它。

样本码

    a := arena.NewArena()
    defer a.Free()

    tt := arena.New[T1](a)
    tt.n = 1

    ts := arena.MakeSlice[T1](a, 99, 100)
    if len(ts) != 99 {
        t.Errorf("Slice() len = %d, want 99", len(ts))
    }
    if cap(ts) != 100 {
        t.Errorf("Slice() cap = %d, want 100", cap(ts))
    }
    ts[1].n = 42

Answer 2

在go 1.19

垃圾收集器增加了对软内存限制的支持，

垃圾收集器增加了对软内存限制的支持，在新的垃圾收集指南中将详细讨论。这个限制特别有助于优化Go程序，以便在具有专用内存的容器中尽可能高效地运行。

新的垃圾收集指南