本文永久链接 – https://tonybai.com/2025/08/15/some-changes-in-go-1-25

大家好，我是Tony Bai。

北京时间2025年8月13日，Go 团队如期发布了 Go 语言的最新大版本——Go 1.25。按照惯例，每次 Go 大版本发布时，我都会撰写一篇“Go 1.x 中值得关注的几个变化”的文章。自 2014 年的 Go 1.4 版本起，这一系列文章已经伴随大家走过了十一个年头。

不过，随着我在版本冻结前推出的“Go 1.x 新特性前瞻”系列，以及对该大版本可能加入特性的一些独立的解读文章，本系列文章的形式也在不断演变。本文将不再对每个特性进行细致入微的分析，因为这些深度内容大多已在之前的《Go 1.25 新特性前瞻》一文中详细讨论过。本文将更聚焦于提炼核心亮点，并分享一些我的思考。

好了，言归正传，我们来看看Go 1.25带来了哪些惊喜！

语言变化：兼容性基石上的精雕细琢

正如 Go 一贯所做的，新版 Go 1.25 继续遵循 Go1 的兼容性规范。最令 Gopher 们安心的一点是：Go 1.25 没有引入任何影响现有 Go 程序的语言级变更。

There are no languages changes that affect Go programs in Go 1.25.

这种对稳定性的极致追求，是 Go 成为生产环境首选语言之一的重要原因。

尽管语法层面波澜不惊，但语言规范内部却进行了一次“大扫除”——移除了“core types”的概念。这一变化虽然对日常编码无直接影响，但它简化了语言规范，为未来泛型可能的演进铺平了道路，体现了 Go 团队在设计层面的严谨与远见。关于此变化的深度解读，可以回顾我之前的文章《Go 1.25 规范大扫除：移除“Core Types”，为更灵活的泛型铺路》。

编译器与运行时：看不见的性能飞跃

如果说 Go 1.24 的运行时核心是优化 map，那么 Go 1.25 的灵魂则在于让 Go 程序更“懂”其运行环境，并对 GC 进行了大刀阔斧的革新。

容器感知型 GOMAXPROCS

这无疑是 Go 1.25 最具影响力的变化之一。在容器化部署已成事实标准的今天，Go 1.25 的运行时终于具备了 cgroup 感知能力。在 Linux 系统上，它会默认根据容器的 CPU limit 来设置 GOMAXPROCS，并能动态适应 limit 的变化。

这意味着，只需升级到 Go 1.25，你的 Go 应用在 K8s 等环境中的 CPU 资源使用将变得更加智能和高效，告别了过去因 GOMAXPROCS 默认值不当而导致的资源浪费或性能瓶颈。更多细节，请参阅我的文章《Go 1.25 新提案：GOMAXPROCS 默认值将迎 Cgroup 感知能力，终结容器性能噩梦？》。

实验性的 Green Tea GC

Go 1.25 迈出了 GC 优化的重要一步，引入了一个新的实验性垃圾收集器。通过设置 GOEXPERIMENT=greenteagc 即可在构建时启用。

A new garbage collector is now available as an experiment. This garbage collector’s design improves the performance of marking and scanning small objects through better locality and CPU scalability.

据官方透露，这个新 GC 有望为真实世界的程序带来 10%—40% 的 GC 开销降低。知名go开发者Josh Baker(@tidwall)在Go 1.25发布正式版后，在X上分享了自己使用go 1.25新gc（绿茶）后的结果，他开源的实时地理空间和地理围栏项目tile38的GC开销下降35%：

这是一个巨大的性能红利，尤其对于重度依赖GC的内存密集型应用。虽然它仍在实验阶段，但其展现的潜力已足够令人兴奋。对 Green Tea GC 设计原理感兴趣的朋友，可以阅读我的文章《Go 新垃圾回收器登场：Green Tea GC 如何通过内存感知显著降低 CPU 开销？》。

此外，Go 1.25 还修复了一个存在于 Go 1.21 至 1.24 版本中可能导致 nil pointer 检查被错误延迟的编译器 bug，并默认启用了 DWARFv5 调试信息，进一步缩小了二进制文件体积并加快了链接速度，对DWARFv5感兴趣的小伙伴儿可以重温一下我之前的《Go 1.25链接器提速、执行文件瘦身：DWARF 5调试信息格式升级终落地》一文，了解详情。

工具链：效率与可靠性的双重提升

强大的工具链是 Go 生产力的核心保障。Go 1.25 在此基础上继续添砖加瓦。

go.mod 新增 ignore 指令

对于大型 Monorepo 项目，go.mod 新增的 ignore 指令是一个福音。它允许你指定 Go 命令在匹配包模式时应忽略的目录，从而在不影响模块依赖的前提下，有效提升大型、混合语言仓库中的构建与扫描效率。关于此特性的详细用法，请见《Go 工具链进化：go.mod 新增 ignore 指令，破解混合项目构建难题》。

支持仓库子目录作为模块根路径

一个长期困扰 Monorepo 管理者和自定义 vanity import 用户的难题在 Go 1.25 中也得到了解决。Go 命令现在支持在解析 go-import meta 标签时，通过新增的 subdir 字段，将 Git 仓库中的子目录指定为模块的根。

这意味着，你可以轻松地将 github.com/my-org/my-repo/foo/bar 目录映射为模块路径 my.domain/bar，而无需复杂的代理或目录结构调整。这个看似微小但备受期待的改进，极大地提升了 Go 模块在复杂项目结构中的灵活性。想了解其来龙去脉和具体配置方法，可以参考我的文章《千呼万唤始出来？Go 1.25解决Git仓库子目录作为模块根路径难题》。

go doc -http：即开即用的本地文档

这是一个虽小但美的改进。新的 go doc -http 选项可以快速启动一个本地文档服务器，并在浏览器中直接打开指定对象的文档。对于习惯于离线工作的开发者来说，这极大地提升了查阅文档的便捷性。详细介绍见《重拾精髓：go doc -http 让离线包文档浏览更便捷》。

go vet 新增分析器

go vet 变得更加智能，新增了两个实用的分析器：

• waitgroup：检查 sync.WaitGroup.Add 的调用位置是否错误（例如在 goroutine 内部调用）。
• hostport：诊断不兼容 IPv6 的地址拼接方式 fmt.Sprintf(“%s:%d”, host, port)，并建议使用 net.JoinHostPort。

这些静态检查能帮助我们在编码阶段就扼杀掉一批常见的并发和网络编程错误。

标准库：功能毕业与实验探索

标准库的演进是每个 Go 版本的重要看点。

testing/synctest 正式毕业

在 Go 1.24 中以实验特性登场的 testing/synctest 包，在 Go 1.25 中正式毕业，成为标准库的一员。它为并发代码测试提供了前所未有的利器，通过虚拟化时间和调度，让编写可靠、无 flakiness 的并发测试成为可能。我曾撰写过一个“征服 Go 并发测试”的微专栏，系统地介绍了该包的设计与实践，欢迎大家订阅学习。

encoding/json/v2 开启实验

这是 Go 1.25 最受关注的实验性特性之一！通过 GOEXPERIMENT=jsonv2 环境变量，我们可以启用一个全新的、高性能的 JSON 实现。

Go 1.25 includes a new, experimental JSON implementation… The new implementation performs substantially better than the existing one under many scenarios.

根据官方说明，json/v2 在解码性能上相较于 v1 有了“巨大”的提升。这是 Go 社区多年来对 encoding/json 包性能诟病的一次正面回应。虽然其 API 仍在演进中，但它预示着 Go 的 JSON 处理能力未来将达到新的高度。对 v2 的初探，可以参考我的文章《手把手带你玩转 GOEXPERIMENT=jsonv2：Go 下一代 JSON 库初探》。jsonv2支持真流式编解码的方法，也可以参考《Go json/v2实战：告别内存爆炸，掌握真流式Marshal和Unmarshal》这篇文章。

sync.WaitGroup.Go：并发模式更便捷

Go 语言的并发编程哲学之一就是让事情保持简单。Go 1.25 在 sync.WaitGroup 上新增的 Go 方法，正是这一哲学的体现。

这个新方法旨在消除 wg.Add(1) 和 defer wg.Done() 这一对经典的样板代码。现在，你可以直接调用 wg.Go(func() { … }) 来启动一个被 WaitGroup 追踪的 goroutine，Add 和 Done 的调用由 Go 方法在内部自动处理。这不仅让代码更简洁，也从根本上避免了因忘记调用 Add 或 Done 而导致的常见并发错误。

关于这个便捷方法的来龙去脉和设计思考，可以回顾我之前的文章《WaitGroup.Go 要来了？Go 官方提案或让你告别 Add 和 Done 样板代码》。

其他：Trace Flight Recorder

最后，我想特别提一下 runtime/trace 包新增的 Flight Recorder API。传统的运行时 trace 功能强大但开销巨大，不适合在生产环境中持续开启。

trace.FlightRecorder 提供了一种轻量级的解决方案：它将 trace 数据持续记录到一个内存中的环形缓冲区。当程序中发生某个重要事件（如一次罕见的错误）时，我们可以调用 FlightRecorder.WriteTo 将最近一段时间的 trace 数据快照保存到文件。这种“事后捕获”的模式，使得在生产环境中调试偶发、疑难的性能或调度问题成为可能，是 Go 诊断能力的一次重大升级。更多详情可以参阅《Go pprof 迎来重大革新：v2 提案详解，告别默认注册，拥抱飞行记录器》。

小结

Go 1.25 的发布，再次彰显了 Go 语言务实求进的核心哲学。它没有追求华而不实的语法糖，而是将精力聚焦于那些能为广大开发者带来“无形收益”的领域：更智能的运行时、更快的 GC、更可靠的编译器、更高效的工具链。

这些看似底层的改进，正是 Go 作为一门“生产力语言”的价值所在。它让开发者可以专注于业务逻辑，而将复杂的系统优化和环境适配，放心地交给 Go 语言自身。

我鼓励大家尽快将 Go 1.25 应用到自己的项目中，亲自感受这些变化带来的提升。Go 的旅程，仍在继续，让我们共同期待它在未来创造更多的可能。

感谢阅读！

如果这篇文章让你对 Go 1.25 新特性有了新的认识，请帮忙 点赞和分享，让更多朋友一起学习和进步！

你的Go技能，是否也卡在了“熟练”到“精通”的瓶颈期？

• 想写出更地道、更健壮的Go代码，却总在细节上踩坑？
• 渴望提升软件设计能力，驾驭复杂Go项目却缺乏章法？
• 想打造生产级的Go服务，却在工程化实践中屡屡受挫？

继《Go语言第一课》后，我的《Go语言进阶课》终于在极客时间与大家见面了！

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造！30+讲硬核内容，带你夯实语法认知，提升设计思维，锻造工程实践能力，更有实战项目串讲。

目标只有一个：助你完成从“Go熟练工”到“Go专家”的蜕变！ 现在就加入，让你的Go技能再上一个新台阶！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

本文永久链接 – https://tonybai.com/2025/08/09/true-streaming-support-in-jsonv2

大家好，我是Tony Bai。

Go 开发者长期以来面临一个痛点：标准库 encoding/json 在处理大型 JSON 数据时，即使使用 Encoder/Decoder，也因其内部的全量缓冲机制而导致巨大的内存开销。备受期待的 encoding/json/v2 提案（#71497）旨在从根本上解决这一问题。通过引入全新的底层包 encoding/json/jsontext，v2 实现了真正的流式处理能力。本文将通过具体的、可量化的基准测试，向你展示 v1 的内存陷阱，并演示如何使用 json/v2 高效地实现流式处理大规模 JSON 数据，彻底告别内存爆炸的烦恼。

json/v1 的“伪流”之痛：一个内存陷阱基准

为了直观地感受 json/v1 在处理大数据时的局限性，我们来建立一个基准测试。我们将分别进行编码（Marshal）和解码（Unmarshal）操作，并观察其内存使用情况。

关于内存评估：我们通过比较操作前后的 runtime.MemStats.TotalAlloc 来精确测量该操作自身导致的堆内存总分配量。一个真正的流式处理，其内存分配量应该是一个很小的常数（例如，I/O 缓冲区的大小），而与数据总量无关。

场景一：v1 编码一个巨大的 JSON 数组

我们创建一个包含 100 万个空结构体的 slice，然后使用 json.Encoder 将其写入 io.Discard。

// jsonv2-streaming/v1/marshal.go
package main

import (
    "encoding/json"
    "io"
    "log"
    "runtime"
)

func main() {
    const numRecords = 1_000_000
    in := make([]struct{}, numRecords)
    out := io.Discard

    // 多次 GC 以清理 sync.Pools，确保测量准确
    for i := 0; i < 5; i++ {
        runtime.GC()
    }

    var statsBefore runtime.MemStats
    runtime.ReadMemStats(&statsBefore)

    log.Println("Starting to encode with json/v1...")
    encoder := json.NewEncoder(out)
    if err := encoder.Encode(&in); err != nil {
        log.Fatalf("v1 Encode failed: %v", err)
    }
    log.Println("Encode finished.")

    var statsAfter runtime.MemStats
    runtime.ReadMemStats(&statsAfter)

    allocBytes := statsAfter.TotalAlloc - statsBefore.TotalAlloc
    log.Printf("Total bytes allocated during Encode: %d bytes (%.2f MiB)", allocBytes, float64(allocBytes)/1024/1024)
}

分析：当你运行此程序，会看到总分配字节数是一个巨大的数字，通常是几兆字节 (MiB)。这是因为 json.Encoder 必须先在内存中将整个 slice 序列化成一个完整的、约几MB（{} 乘以 100 万）的 JSON 字符串，然后才开始写入。这个巨大的字符串就是内存分配的来源。

在我的Mac上，这个程序的输出如下：

$go run unmarshal.go
2025/08/09 13:38:47 Starting to decode with json/v1...
2025/08/09 13:38:47 Decode finished.
2025/08/09 13:38:47 Total bytes allocated during Decode: 8394096 bytes (8.01 MiB)

下面再来看看v1版本的json解码。

场景二：v1 解码一个巨大的 JSON 数组

现在，我们构造一个代表百万空对象的 JSON 字符串，并使用 json.Decoder 解码。

// jsonv2-streaming/v1/unmarshal.go
package main

import (
    "encoding/json"
    "log"
    "runtime"
    "strings"
)

func main() {
    const numRecords = 1_000_000
    // 构造一个巨大的 JSON 数组字符串，约 2MB
    value := "[" + strings.TrimSuffix(strings.Repeat("{},", numRecords), ",") + "]"
    in := strings.NewReader(value)

    // 预分配 slice 容量，以排除 slice 自身扩容对内存测量的影响
    out := make([]struct{}, 0, numRecords)

    for i := 0; i < 5; i++ {
        runtime.GC()
    }

    var statsBefore runtime.MemStats
    runtime.ReadMemStats(&statsBefore)

    log.Println("Starting to decode with json/v1...")
    decoder := json.NewDecoder(in)
    if err := decoder.Decode(&out); err != nil {
        log.Fatalf("v1 Decode failed: %v", err)
    }
    log.Println("Decode finished.")

    var statsAfter runtime.MemStats
    runtime.ReadMemStats(&statsAfter)

    allocBytes := statsAfter.TotalAlloc - statsBefore.TotalAlloc
    log.Printf("Total bytes allocated during Decode: %d bytes (%.2f MiB)", allocBytes, float64(allocBytes)/1024/1024)
}

分析：同样，你会看到数兆字节的内存分配。json.Decoder 在反序列化之前，会将整个 JSON 数组作为一个单独的值完整地读入其内部缓冲区。这个缓冲区的大小与输入数据的大小成正比。

运行该代码，我机器上的输出如下：

$go run unmarshal.go
2025/08/09 13:38:47 Starting to decode with json/v1...
2025/08/09 13:38:47 Decode finished.
2025/08/09 13:38:47 Total bytes allocated during Decode: 8394096 bytes (8.01 MiB)

从上面两个例子，我们看到：json/v1 的 Encoder 和 Decoder 提供的只是API 层面的流式抽象，其底层实现是全量缓冲的，导致内存复杂度和数据大小成线性关系 (O(N))。这就是“伪流”之痛。

json/v2 的革命：用正确的 API 实现真流式处理

现在，让我们见证 json/v2 的魔力。我们将使用 v2 推荐的流式 API，来完成与 v1 示例完全相同的任务，并进行内存对比。

场景一：v2 流式编码一个巨大的 JSON 数组

我们将模拟从数据源逐条获取数据，并使用 jsontext.Encoder 手动构建 JSON 数组流。

// jsonv2-streaming/v2/marshal.go
package main

import (
    "io"
    "log"
    "runtime"
    "encoding/json/v2"
    "encoding/json/jsontext"
)

func main() {
    const numRecords = 1_000_000
    out := io.Discard

    for i := 0; i < 5; i++ {
        runtime.GC()
    }

    var statsBefore runtime.MemStats
    runtime.ReadMemStats(&statsBefore)

    log.Println("Starting to encode with json/v2...")

    enc := jsontext.NewEncoder(out)

    // 手动写入数组开始标记
    if err := enc.WriteToken(jsontext.BeginArray); err != nil {
        log.Fatalf("Failed to write array start: %v", err)
    }

    // 逐个编码元素
    for i := 0; i < numRecords; i++ {
        // 内存中只需要一个空结构体，几乎不占空间
        record := struct{}{}
        if err := json.MarshalEncode(enc, record); err != nil {
            log.Fatalf("v2 MarshalEncode failed for record %d: %v", i, err)
        }
    }

    // 手动写入数组结束标记
    if err := enc.WriteToken(jsontext.EndArray); err != nil {
        log.Fatalf("Failed to write array end: %v", err)
    }
    log.Println("Encode finished.")

    var statsAfter runtime.MemStats
    runtime.ReadMemStats(&statsAfter)

    allocBytes := statsAfter.TotalAlloc - statsBefore.TotalAlloc
    log.Printf("Total bytes allocated during Encode: %d bytes (%.2f KiB)", allocBytes, float64(allocBytes)/1024)
}

分析：运行此程序，你会看到总分配字节数是一个非常小的数字，通常是几十千字节 (KiB)，主要用于 Encoder 内部的 I/O 缓冲。v2 将每个元素编码后立即写入，没有在内存中构建那个 2MB 的巨大字符串。

在我的机器上运行该示例，编码过程实际分配的内存仅有不到15KB：

$GOEXPERIMENT=jsonv2 go run marshal.go
2025/08/09 13:45:50 Starting to encode with json/v2...
2025/08/09 13:45:50 Encode finished.
2025/08/09 13:45:50 Total bytes allocated during Encode: 15328 bytes (14.97 KiB)

场景二：v2 流式解码一个巨大的 JSON 数组

我们将使用 jsontext.Decoder 和 jsonv2.UnmarshalDecode 的组合来逐个解码元素。

// jsonv2-streaming/v2/unmarshal.go
package main

import (
    "errors"
    "io"
    "log"
    "runtime"
    "strings"
    "encoding/json/v2"
    "encoding/json/jsontext"
)

func main() {
    const numRecords = 1_000_000
    value := "[" + strings.TrimSuffix(strings.Repeat("{},", numRecords), ",") + "]"
    in := strings.NewReader(value)
    _ = make([]struct{}, 0, numRecords) // out 变量在实际应用中会用到

    for i := 0; i < 5; i++ {
        runtime.GC()
    }

    var statsBefore runtime.MemStats
    runtime.ReadMemStats(&statsBefore)

    log.Println("Starting to decode with json/v2...")

    dec := jsontext.NewDecoder(in)

    // 手动读取数组开始标记 '['
    tok, err := dec.ReadToken()
    if err != nil || tok.Kind() != '[' {
        log.Fatalf("Expected array start, got %v, err: %v", tok, err)
    }

    // 循环解码数组中的每个元素
    for dec.PeekKind() != ']' {
        var record struct{}
        if err := json.UnmarshalDecode(dec, &record); err != nil {
            if errors.Is(err, io.EOF) {
                break
            }
            log.Fatalf("v2 UnmarshalDecode failed: %v", err)
        }
        // 在实际应用中，这里会处理 record，例如：
        // out = append(out, record)
    }
    log.Println("Decode finished.")

    var statsAfter runtime.MemStats
    runtime.ReadMemStats(&statsAfter)

    allocBytes := statsAfter.TotalAlloc - statsBefore.TotalAlloc
    log.Printf("Total bytes allocated during Decode: %d bytes (%.2f KiB)", allocBytes, float64(allocBytes)/1024)
}

分析：同样，你会看到总分配字节数非常小。UnmarshalDecode 在循环中每次只读取并解码一个 {} 对象，而 jsontext.Decoder 的内部缓冲区大小是固定的，不会因输入流的增大而膨胀。

下面是我机器上运行的结果，和v2编码一样，仅需要15KB左右的缓冲区：

$ GOEXPERIMENT=jsonv2 go run unmarshal.go
2025/08/09 13:55:29 Starting to decode with json/v2...
2025/08/09 13:55:29 Decode finished.
2025/08/09 13:55:29 Total bytes allocated during Decode: 15248 bytes (14.89 KiB)

内存占用对比总结

这个直接的、数据驱动的对比，无可辩驳地证明了 json/v2 在流式处理方面的革命性突破。它将内存复杂度从 O(N) 降低到了 O(1)，为 Go 语言处理海量 JSON 数据铺平了道路。

正如提出issue #33714的开发者flimzy所说的那样：json/v2正是json流处理的答案！

小结

encoding/json/v2 的提案和实现，标志着 Go 在大规模数据处理能力上的一个巨大飞跃。通过将语法和语义分离，并提供底层的、真正的流式 API，v2 彻底解决了 v1 长期存在的内存瓶颈问题。

对于 Go 开发者而言，这意味着：

• 处理超大规模 JSON 不再是难题**：无论是生成还是解析 GB 级别的 JSON 文件或流，都将变得轻而易举，且内存占用可控。
• 更高的性能和效率：根据 v2 的基准测试，新的实现在解码（Unmarshal）方面比 v1 有 2.7 到 10.2 倍的性能提升。
• 更灵活的控制力：底层的 jsontext 包为需要进行精细化 JSON 操作的开发者提供了前所未有的能力。

虽然 Go 1.25 json/v2 会以 GOEXPERIMENT 形式落地，但它所展示的强大能力和优秀设计，已经预示了Go JSON 处理的新纪元。我们有充分的理由期待它在未来的 Go 版本中正式发布，成为所有 Go 开发者处理 JSON 数据的首选工具。

本文涉及的示例代码可以在这里下载。

你的Go技能，是否也卡在了“熟练”到“精通”的瓶颈期？

• 想写出更地道、更健壮的Go代码，却总在细节上踩坑？
• 渴望提升软件设计能力，驾驭复杂Go项目却缺乏章法？
• 想打造生产级的Go服务，却在工程化实践中屡屡受挫？

继《Go语言第一课》后，我的《Go语言进阶课》终于在极客时间与大家见面了！

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造！30+讲硬核内容，带你夯实语法认知，提升设计思维，锻造工程实践能力，更有实战项目串讲。

目标只有一个：助你完成从“Go熟练工”到“Go专家”的蜕变！ 现在就加入，让你的Go技能再上一个新台阶！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。