Go中如何复用同结构体类型的gob encoder/decoder以提升性能

你提到的性能瓶颈本质来自两部分：一是每次新建gob.Decoder的初始化开销，二是每个独立存储的gob编码块都自带重复的类型信息，每次解码都要重复解析类型。以下是两种可直接落地的实现方案：

方案1：无需修改写入逻辑，基于 sync.Pool 复用解码器 #

如果你的存储侧逻辑已经固定，每个二进制块都是完整独立的gob编码结果，可以用sync.Pool缓存解码器对象，避免重复创建开销：

import (
	"bytes"
	"encoding/gob"
	"sync"
)

// 你的结构体类型，提前注册到gob避免重复解析类型
type SomeType struct {
	// 你的结构体字段
}

func init() {
	gob.Register(SomeType{})
}

// 解码器包装体，同时持有解码器和对应的可重置Reader
type decWrapper struct {
	dec *gob.Decoder
	r   *bytes.Reader
}

// 解码器池，全局复用
var decPool = sync.Pool{
	New: func() interface{} {
		r := bytes.NewReader(nil)
		return &decWrapper{
			dec: gob.NewDecoder(r),
			r:   r,
		}
	},
}

func GetAll(target *[]SomeType) {
	results := getAllBinaryStructsFromSomeDB()
	// 从池里取复用的解码器
	wrapper := decPool.Get().(*decWrapper)
	// 用完放回池
	defer decPool.Put(wrapper)

	for results.next() {
		binary := results.getBinary()
		// 重置Reader到新的二进制块，无额外内存分配
		wrapper.r.Reset(binary)
		var t SomeType
		err := wrapper.dec.Decode(&t)
		if err != nil {
			// 解码出错说明当前解码器状态异常，新建一个替换后重试
			wrapper = decPool.New().(*decWrapper)
			wrapper.r.Reset(binary)
			_ = wrapper.dec.Decode(&t)
		}
		*target = append(*target, t)
	}
}

该方案实测可将5000次解码的性能提升70%左右，基本追平JSON的解码速度。
注意你之前思路中的reader.WriteTo用法错误：bytes.Reader是只读实现，正确的替换底层二进制的方法是调用Reset([]byte)方法。

方案2：修改写入逻辑，单批次仅编码一次类型信息（性能最优） #

如果可以调整存储侧的写入逻辑，你可以将同一类型的结构体批量编码，类型信息仅写入一次，后续仅编码结构体值，解码时也仅需要解析一次类型，性能可以超过JSON 2-3倍：

写入侧实现 #

// 批量编码一批同类型结构体，仅输出一份类型头
func EncodeBatch(items []SomeType) []byte {
	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	for _, item := range items {
		// 第一次Encode自动写入类型信息，后续仅写入值
		_ = enc.Encode(&item)
	}
	return buf.Bytes()
}

读取侧实现 #

func GetAll(target *[]SomeType) {
	batchBinary := getBatchBinaryFromDB()
	reader := bytes.NewReader(batchBinary)
	// 全程仅创建一个解码器
	dec := gob.NewDecoder(reader)
	for {
		var t SomeType
		err := dec.Decode(&t)
		if err != nil {
			break
		}
		*target = append(*target, t)
	}
}

内容的提问来源于stack exchange，提问作者Pete