Go1.19自定义格式时间反序列化如何避免string(b)堆逃逸？

go1.19 - 本问题对应的Go版本。

由于需要处理自定义格式的时间，必须实现自定义UnmarshalJSON方法。当前自定义UnmarshalJSON方法中的string(b)会发生堆逃逸，推测由time.Parse()函数导致。因为要反序列化大量对象，这种实现方式性能不理想，希望消除堆逃逸问题。

原问题代码 #

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "strings"
    "time"
)

const customTimeLayout = "02-01-2006 15:04"

type customTime struct {
    time.Time
}

func (ct *customTime) UnmarshalJSON(b []byte) error {
    s := string(b) // escapes to heap

    s = strings.Trim(s, "\"")

    t, err := time.Parse(customTimeLayout, s)
    if err != nil {
        return fmt.Errorf("failed to parse time: %w", err)
    }

    ct.Time = t

    return nil
}

func main() {
    jsonData := []byte("\"31-12-2022 16:00\"")

    var unmarshalled customTime
    err := json.Unmarshal(jsonData, &unmarshalled)
    if err != nil {
        log.Fatal(err)
    }
}

解决方案 #

方案1：优化byte切片操作+无拷贝string转换

原代码先将整个JSON字节切片转成string再去除引号，会产生多余内存拷贝，且完整string易被time.Parse持有引用导致堆逃逸。优化后直接操作字节切片截取有效时间部分，并用unsafe.String避免内存拷贝：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "time"
    "unsafe"
)

const customTimeLayout = "02-01-2006 15:04"

type customTime struct {
    time.Time
}

func (ct *customTime) UnmarshalJSON(b []byte) error {
    // 校验格式是否包含首尾引号
    if len(b) < 2 || b[0] != '"' || b[len(b)-1] != '"' {
        return fmt.Errorf("invalid time format: missing surrounding quotes")
    }
    // 截取去除引号后的有效时间字节切片
    timeBytes := b[1 : len(b)-1]
    // 无拷贝转换为string（Go 1.17+支持，当前版本1.19兼容）
    s := unsafe.String(&timeBytes[0], len(timeBytes))

    t, err := time.Parse(customTimeLayout, s)
    if err != nil {
        return fmt.Errorf("failed to parse time: %w", err)
    }

    ct.Time = t
    return nil
}

func main() {
    jsonData := []byte("\"31-12-2022 16:00\"")

    var unmarshalled customTime
    err := json.Unmarshal(jsonData, &unmarshalled)
    if err != nil {
        log.Fatal(err)
    }
}

说明：

• unsafe.String直接将字节切片的内存映射为string，避免了传统string([]byte)的内存拷贝，大幅降低内存开销和堆逃逸概率
• 先校验并截取有效时间部分，只转换必要的字节内容，进一步减少内存占用

方案2：手动解析时间字段（极致性能）

如果对性能要求极高，可以完全绕过time.Parse，手动解析字节切片中的日、月、年、时、分字段，彻底消除string转换带来的逃逸问题：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "strconv"
    "time"
)

const customTimeLayout = "02-01-2006 15:04"

type customTime struct {
    time.Time
}

func (ct *customTime) UnmarshalJSON(b []byte) error {
    // 校验格式长度是否匹配预期
    expectedLen := len("\"02-01-2006 15:04\"")
    if len(b) != expectedLen || b[0] != '"' || b[len(b)-1] != '"' {
        return fmt.Errorf("invalid time format")
    }

    // 手动解析各个时间字段
    day, err := strconv.Atoi(string(b[1:3]))
    if err != nil {
        return fmt.Errorf("invalid day: %w", err)
    }
    month, err := strconv.Atoi(string(b[4:6]))
    if err != nil {
        return fmt.Errorf("invalid month: %w", err)
    }
    year, err := strconv.Atoi(string(b[7:11]))
    if err != nil {
        return fmt.Errorf("invalid year: %w", err)
    }
    hour, err := strconv.Atoi(string(b[12:14]))
    if err != nil {
        return fmt.Errorf("invalid hour: %w", err)
    }
    min, err := strconv.Atoi(string(b[15:17]))
    if err != nil {
        return fmt.Errorf("invalid minute: %w", err)
    }

    // 构造time.Time对象
    ct.Time = time.Date(year, time.Month(month), day, hour, min, 0, 0, time.UTC)
    return nil
}

func main() {
    jsonData := []byte("\"31-12-2022 16:00\"")

    var unmarshalled customTime
    err := json.Unmarshal(jsonData, &unmarshalled)
    if err != nil {
        log.Fatal(err)
    }
}

说明：

• 完全避免了time.Parse调用，消除了其内部逻辑导致的堆逃逸
• 仅对单个字段的字节片段做临时string转换，内存占用极低
• 缺点是需要严格匹配固定格式，格式变动时需同步修改解析逻辑

验证逃逸情况 #

可以通过Go编译参数验证堆逃逸是否消除：

go build -gcflags="-m" main.go

观察输出中是否再出现escapes to heap的相关提示。

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