Go语言包内部缓冲区内存管理最佳实践

// Foo 函数将 Bar 类型的数据编码到 dst 切片中。
// 如果 dst 足够容纳编码后的数据，则返回 dst 的子切片。
// 否则，将分配一个新的切片并返回。
// 传入 nil 的 dst 是有效的，此时函数会自行分配。
func Foo(dst []byte, data Bar) (ret []byte, err error) {
    // 假设 encodeData 是一个内部函数，用于实际的编码逻辑
    requiredLen := calculateEncodedLen(data)

    if cap(dst) >= requiredLen {
        // dst 容量足够，直接使用
        ret = dst[:requiredLen] // 截取到所需长度
    } else {
        // dst 容量不足，或 dst 为 nil，需要重新分配
        ret = make([]byte, requiredLen)
    }

    // 将 data 编码到 ret 中
    // ... (实际编码逻辑) ...

    return ret, nil
}

// 假设 Bar 是一个结构体或接口
type Bar struct {
    Value string
    Count int
}

func calculateEncodedLen(data Bar) int {
    // 根据 Bar 的内容计算编码后所需的字节数
    return len(data.Value) + 8 // 示例：字符串长度 + 整数的字节数
}

// 客户端使用示例
func main() {
    myBar := Bar{Value: "hello", Count: 123}

    // 第一次调用，可能没有预设缓冲区
    result1, err := Foo(nil, myBar)
    if err != nil {
        // handle error
    }
    fmt.Printf("Result 1: %s\n", string(result1))

    // 第二次调用，提供一个预先分配的缓冲区
    // 假设我们知道通常需要约 20 字节
    buffer := make([]byte, 0, 20)
    result2, err := Foo(buffer, myBar)
    if err != nil {
        // handle error
    }
    fmt.Printf("Result 2: %s\n", string(result2))

    // 如果 buffer 足够大，result2 将是 buffer 的一个子切片。
    // 这样可以避免内部再次分配。
}

import (
    "bytes"
    "sync"
)

// 定义一个缓冲区池，用于 []byte 切片
// New 字段指定当池中没有可用对象时如何创建新对象
var bufferPool = sync.Pool{
    New: func() interface{} {
        // 创建一个初始容量为 1KB 的 []byte 切片
        // 实际大小可根据应用场景调整
        return make([]byte, 0, 1024)
    },
}

// ProcessData 使用缓冲区池处理数据
func ProcessData(input string) ([]byte, error) {
    // 从池中获取一个缓冲区
    buf := bufferPool.Get().([]byte)
    // 确保函数退出时将缓冲区返回池中
    defer func() {
        // 重置切片长度，但保留容量，以便下次复用
        buf = buf[:0]
        bufferPool.Put(buf)
    }()

    // 使用 buf 进行数据处理，例如写入字符串
    // bytes.Buffer 是一个方便的工具，可以包装 []byte
    // 实际应用中可能直接操作 []byte
    writer := bytes.NewBuffer(buf)
    _, err := writer.WriteString(input)
    if err != nil {
        return nil, err
    }

    // 如果 writer 内部扩容导致新的底层数组，我们应该返回 writer.Bytes()
    // 并且在 defer 中 put 的仍然是原始的 buf，这需要注意。
    // 更安全的做法是：如果 writer 内部扩容，就让新的大数组自然GC，
    // 只有在原始 buf 未扩容时才将其返回池中。
    // 或者，自定义一个管理 []byte 的结构体，包含其原始容量信息。

    // 为了简化示例，假设 writer.Bytes() 返回的是原始 buf 或其子切片，
    // 并且我们希望返回一个独立的数据副本。
    // 在实际应用中，你可能需要返回一个拷贝，或者确保返回的切片不会被池中的其他使用者修改。
    return append([]byte(nil), writer.Bytes()...), nil
}

func main() {
    data1 := "This is some data to process."
    result1, _ := ProcessData(data1)
    fmt.Printf("Result 1: %s\n", string(result1))

    data2 := "Another piece of information, possibly longer."
    result2, _ := ProcessData(data2)
    fmt.Printf("Result 2: %s\n", string(result2))
    // 这里的 result1 和 result2 是独立的拷贝，不会互相影响。
    // 但底层的缓冲区 buf 已经被复用了。
}