Go 1.13 相比 Go 1.12 有哪些值得注意的改动？

本系列旨在梳理 Go 的 release notes 与发展史，来更加深入地理解 Go 语言设计的思路。

https://go.dev/doc/go1.13

Go 1.13 带来了一系列语言、工具链、运行时和标准库的改进。以下是一些值得开发者关注的重点改动：

1. 语言特性 ： 引入了更统一和现代化的数字字面量表示法，包括二进制 (0b)、八进制 (0o) 前缀、十六进制浮点数、数字分隔符 (_) 等，并取消了移位操作计数必须为无符号数的限制。
2. Go Modules 与 Go 命令 ： GO111MODULE=auto 在检测到 go.mod 文件时将默认启用模块感知模式，即使在 GOPATH 内；引入 GOPRIVATE 等环境变量更好地管理私有模块和代理配置；go get -u 的更新逻辑有所调整；go 命令增加了如 go env -w、go version <executable>、go build -trimpath 等新功能。
3. Runtime 运行时 ： 优化了切片越界时的 panic 信息，使其包含越界索引和切片长度；defer 的性能在大多数场景下提升了约 30%；运行时会更积极地将不再使用的内存归还给操作系统。
4. 错误处理 ： 正式引入了 错误包装（error wrapping）机制，通过 fmt.Errorf 的新 %w 动词和 errors 包新增的 Unwrap、Is、As 函数，可以创建和检查包含原始错误上下文的错误链。
5. sync 包 ： 通过内联优化，sync.Mutex、sync.RWMutex 和 sync.Once 在非竞争情况下的性能得到提升（锁操作约 10%，Once.Do 约 2 倍）；sync.Pool 对 GC 暂停时间（STW）的影响减小，并且能在 GC 后保留部分对象，减少 GC 后的冷启动开销。

下面是一些值得展开的讨论：

语言特性：更现代化的数字字面量与有符号位移

Go 1.13 在语言层面引入了几项旨在提升代码可读性和易用性的改进。

首先是数字字面量的增强：

• 二进制字面量 (Binary Literals) ： 使用前缀 0b 或 0B 表示二进制整数，例如 0b1011 代表十进制的 11。
• 八进制字面量 (Octal Literals) ： 使用前缀 0o 或 0O 表示八进制整数，例如 0o660 代表十进制的 432。需要注意的是，旧式的以 0 开头的八进制表示法（如 0660）仍然有效，但推荐使用新的 0o 前缀以避免歧义。
• 十六进制浮点数字面量 (Hexadecimal Floating-point Literals) ： 允许使用 0x 或 0X 前缀表示浮点数的尾数部分，但必须带有一个以 p 或 P 开头的二进制指数。例如 0x1.0p-2 表示 $1.0 * 2^{-2}$，即 0.25。
• 虚数字面量后缀 (Imaginary Literals) ： 虚数后缀 i 现在可以用于任何整数或浮点数字面量（二进制、八进制、十进制、十六进制），如 0b1011i、0o660i、3.14i、0x1.fp+2i。
• 数字分隔符 (Digit Separators) ： 可以使用下划线 _ 来分隔数字，以提高长数字的可读性，例如 1_000_000、0b_1010_0110 或 3.1415_9265。下划线可以出现在任意两个数字之间，或者前缀和第一个数字之间。

package main

import "fmt"

func main() {
    binaryNum := 0b1101 // 13
    octalNum := 0o755   // 493
    hexFloat := 0x1.Fp+2 // 1.9375 * 2^2 = 7.75
    largeNum := 1_000_000_000
    complexNum := 0xAp1 + 1_2i // (10 * 2^1) + 12i = 20 + 12i

    fmt.Println(binaryNum)
    fmt.Println(octalNum)
    fmt.Println(hexFloat)
    fmt.Println(largeNum)
    fmt.Println(complexNum)
    // 13
    // 493
    // 7.75
    // 1000000000
    // (20+12i)
}

其次，Go 1.13 取消了移位操作（<< 和 >>）的移位计数（右操作数）必须是无符号整数的限制。现在可以直接使用有符号整数作为移位计数。

这消除了之前为了满足类型要求而进行的许多不自然的 uint 转换。

package main

import "fmt"

func main() {
    var signedShift int = 2
    var value int64 = 100

    // Go 1.12 及之前: 需要显式转换为 uint
    // shiftedValueOld := value << uint(signedShift)

    // Go 1.13 及之后: 可以直接使用 signed int
    shiftedValueNew := value << signedShift

    // fmt.Println(shiftedValueOld) // 输出 400
    fmt.Println(shiftedValueNew) // 输出 400

    var negativeShift int = -2 // 负数移位也是允许的，但行为依赖于具体实现和架构，通常不建议
    fmt.Println(value >> negativeShift) // 行为可能非预期，输出可能为 0 或 panic，取决于 Go 版本和具体情况
}

400
panic: runtime error: negative shift amount

goroutine 1 [running]:
main.main()
        /home/piperliu/code/playground/main.go:19 +0x85
exit status 2

需要注意的是，要使用这些新的语言特性，你的项目需要使用 Go Modules，并且 go.mod 文件中声明的 Go 版本至少为 1.13。你可以手动编辑 go.mod 文件，或者运行 go mod edit -go=1.13 来更新。

Go Modules 与 Go 命令：模块化体验改进与工具增强

Go 1.13 在 Go Modules 和 go 命令行工具方面带来了重要的改进，旨在简化开发流程和模块管理。

模块行为与环境变量

• GO111MODULE=auto 的行为变化：现在，只要当前工作目录或其任何父目录包含 go.mod 文件，auto 设置就会激活模块感知模式。这意味着即使项目位于传统的 GOPATH/src 目录下，只要存在 go.mod，go 命令也会优先使用模块模式。这极大地简化了从 GOPATH 迁移到 Modules 的过程以及混合管理两种模式项目的场景。
• 新的环境变量 GOPRIVATE、GONOPROXY、GONOSUMDB：为了更好地处理私有模块（例如公司内部的代码库），引入了 GOPRIVATE 环境变量。它用于指定一组不应通过公共代理 (GOPROXY) 下载或通过公共校验和数据库 (GOSUMDB) 验证的模块路径模式（支持通配符）。GOPRIVATE 会作为 GONOPROXY 和 GONOSUMDB 的默认值，提供更细粒度的控制。
• GOPROXY 默认值与配置：GOPROXY 环境变量现在支持逗号分隔的代理 URL 列表，以及特殊值 direct（表示直接连接源仓库）。其默认值更改为 https://proxy.golang.org,direct。go 命令会按顺序尝试列表中的每个代理，直到成功下载或遇到非 404/410 错误。
• GOSUMDB：用于指定校验和数据库的名称和可选的公钥及 URL。默认值为 sum.golang.org。如果模块不在主模块的 go.sum 文件中，go 命令会查询 GOSUMDB 以验证下载模块的哈希值，确保依赖未被篡改。可以设置为 off 来禁用此检查。

对于无法访问公共代理或校验和数据库的环境（如防火墙内），可以使用 go env -w 命令设置全局默认值：

# 仅直接从源仓库下载，不使用代理
go env -w GOPROXY=direct

# 禁用校验和数据库检查
go env -w GOSUMDB=off

# 配置私有模块路径 (示例)
go env -w GOPRIVATE=*.corp.example.com,github.com/my-private-org/*

go get 行为调整

• go get -u 的更新范围：在模块模式下，go get -u （不带包名参数时）现在只更新当前目录包的直接和间接依赖。这与 GOPATH 模式下的行为更一致。如果要更新 go.mod 中定义的所有依赖（包括测试依赖）到最新版本，应使用 go get -u all。
• go get -u <package> 的更新范围：当指定包名时，go get -u <package> 会更新指定的包及其导入的包所在的模块，而不是这些模块的所有传递依赖。
• @patch 版本后缀：go get 支持了新的 @patch 版本后缀。例如 go get example.com/mod@patch 会将 example.com/mod 更新到当前主版本和次版本下的最新补丁版本。
• @upgrade 和 @latest：@upgrade 明确要求将模块升级到比当前更新的版本（如果没有新版本则保持不变，防止意外降级预发布版本）。@latest 则总是尝试获取最新的发布版本，无论当前版本如何。

版本校验增强

go 命令在处理模块版本时增加了更严格的校验：

• +incompatible 版本：如果一个仓库使用了 +incompatible 标记（通常用于 Modules 出现之前的 v2+ 版本），go 命令现在会验证该版本对应的代码树中 不能 包含 go.mod 文件。
• 伪版本 (Pseudo-versions)：对形如 vX.Y.Z-yyyymmddhhmmss-abcdefabcdef 的伪版本格式进行了更严格的校验，确保版本前缀、时间戳和 commit 哈希与版本控制系统的元数据一致。如果 go.mod 中有无效的伪版本，通常可以通过将其简化为 commit 哈希（如 require example.com/mod abcdefabcdef）然后运行 go mod tidy 或 go list -m all 来自动修正。对于传递依赖中的无效版本，可以使用 replace 指令强制替换为有效的版本或 commit 哈希。

其他 go 命令改进

• go env -w 和 -u：允许设置和取消设置 go 命令环境变量的用户级默认值，存储在用户配置目录下的 go/env 文件中。
• go version <executable> 或 <directory>：可以查看 Go 二进制文件是用哪个 Go 版本编译的（使用 -m 标志可查看嵌入的模块信息），或查看目录及其子目录下所有 Go 二进制文件的版本信息。
• go build -trimpath：一个新的构建标志，用于从编译出的二进制文件中移除所有本地文件系统路径信息，有助于提高构建的可复现性。

错误处理：官方错误包装（Error Wrapping）机制

Go 1.13 引入了一个重要的原生机制来处理错误： 错误包装 (error wrapping) 。这个特性解决了长期以来在 Go 中处理错误时的一个痛点：如何在添加上下文信息的同时，保留底层原始错误以便进行程序化检查。

问题背景

在 Go 1.13 之前，当一个函数遇到来自底层调用的错误，并想添加更多关于当前操作的上下文信息时，通常的做法是使用 fmt.Errorf 创建一个新的错误字符串，包含原始错误的信息（通过 %v 或 err.Error()）。

// Go 1.13 之前的常见做法
func readFile(path string) error {
    f, err := os.Open(path)
    if err != nil {
        // 创建了新错误，丢失了原始 err 的类型信息 (如 *os.PathError)
        return fmt.Errorf("failed to open file %q: %v", path, err)
    }
    // ...
    defer f.Close()
    return nil
}

func checkPermission() {
    err := readFile("/path/to/protected/file")
    // 无法直接判断 err 是否是权限错误，因为原始的 os.ErrPermission 信息丢失了
    // if err == os.ErrPermission { ... } // 这通常行不通
}

这种方式的问题在于，返回的错误是一个全新的 string 类型的错误（由 fmt.Errorf 创建），原始错误的类型信息（例如 *os.PathError）和值（例如 os.ErrNotExist）丢失了。调用者无法方便地检查错误的根本原因，例如判断它是不是一个特定的错误类型或哨兵错误值（sentinel error）。

Go 1.13 的解决方案：%w, Unwrap, Is, As

Go 1.13 通过以下方式解决了这个问题：

1. fmt.Errorf 的 %w 动词

fmt.Errorf 函数增加了一个新的格式化动词 %w。当使用 %w 来格式化一个错误时，fmt.Errorf 会创建一个新的错误，这个新错误不仅包含了格式化后的字符串信息，还 包装 (wrap) 了原始的错误。这个包装后的错误会实现一个 Unwrap() error 方法，该方法返回被包装的原始错误。

package main

import (
    "errors"
    "fmt"
    "os"
    "io/fs" // fs.ErrNotExist 在 Go 1.16 引入，之前是 os.ErrNotExist
)

// queryDatabase 模拟数据库查询错误
var ErrDBConnection = errors.New("database connection failed")

func queryDatabase(query string) error {
    // 模拟连接失败
    return ErrDBConnection
}

// handleRequest 处理请求，调用数据库查询
func handleRequest(req string) error {
    err := queryDatabase(req)
    if err != nil {
        // 使用 %w 包装原始错误 ErrDBConnection
        return fmt.Errorf("failed to handle request '%s': %w", req, err)
    }
    return nil
}

// readFileWithErrorWrapping 示例
func readFileWithErrorWrapping(path string) error {
    _, err := os.Open(path)
    if err != nil {
        // 使用 %w 包装 os.Open 返回的错误
        return fmt.Errorf("error opening file %s: %w", path, err)
    }
    return nil
}


func main() {
    // 场景1：检查特定的哨兵错误
    err := handleRequest("SELECT * FROM users")
    if err != nil {
        fmt.Printf("Original error: %v\n", err) // 输出包含包装信息

        // 使用 errors.Is 检查错误链中是否包含 ErrDBConnection
        if errors.Is(err, ErrDBConnection) {
            fmt.Println("Error check passed: The root cause is ErrDBConnection.")
        } else {
            fmt.Println("Error check failed: The root cause is NOT ErrDBConnection.")
        }
    }

    fmt.Println("---")

    // 场景2：检查特定的错误类型并获取其值
    errFile := readFileWithErrorWrapping("non_existent_file.txt")
    if errFile != nil {
        fmt.Printf("Original file error: %v\n", errFile)

        // 使用 errors.As 检查错误链中是否有 *fs.PathError 类型
        // 并将该类型的错误值赋给 pathErr
        var pathErr *fs.PathError
        if errors.As(errFile, &pathErr) {
            fmt.Printf("Error check passed: It's a PathError.\n")
            fmt.Printf("  Operation: %s\n", pathErr.Op)
            fmt.Printf("  Path: %s\n", pathErr.Path)
            fmt.Printf("  Underlying error: %v\n", pathErr.Err) // 底层具体错误
        } else {
            fmt.Println("Error check failed: It's NOT a PathError.")
        }

        // 也可以用 errors.Is 检查底层的哨兵错误
        if errors.Is(errFile, fs.ErrNotExist) {
            fmt.Println("Further check: The underlying error IS fs.ErrNotExist.")
        }
    }
}

2. errors.Unwrap(err error) error

这个函数接收一个错误 err。如果 err 实现了 Unwrap() error 方法，errors.Unwrap 会调用它并返回其结果（即被包装的那个错误）。如果 err 没有包装其他错误，则返回 nil。这允许你手动地逐层解开错误链。

3. errors.Is(err error, target error) bool

这是检查错误链的首选方式。它会递归地解开 err 的错误链（通过调用 Unwrap），检查链中的任何一个错误是否 等于 target 哨兵错误值（使用 == 比较）。如果找到匹配项，返回 true。这对于检查是否发生了某个已知的、预定义的错误（如 io.EOF, sql.ErrNoRows, 或自定义的哨兵错误）非常有用。

4. errors.As(err error, target interface{}) bool

这也是检查错误链的首选方式。它会递归地解开 err 的错误链，检查链中的任何一个错误是否可以赋值给 target 指向的类型。如果找到匹配项，它会将该错误值赋给 target（target 必须是一个指向错误类型接口或具体错误类型的指针），并返回 true。这对于检查错误是否属于某个特定类型，并希望获取该类型错误的具体字段信息（如 *os.PathError 的 Op 和 Path 字段）非常有用。

最佳实践

• 当你想给一个错误添加上下文，并且希望调用者能够检查或响应原始错误时，使用 fmt.Errorf 的 %w 动词进行包装。
• 当你只想记录错误信息，不关心调用者是否需要检查原始错误时，继续使用 %v 或 err.Error()。
• 优先使用 errors.Is 来检查错误链中是否包含特定的哨兵错误值。
• 优先使用 errors.As 来检查错误链中是否包含特定类型的错误，并获取该错误的值以访问其字段。
• 避免直接调用 Unwrap 方法，除非你有特殊需要逐层处理错误链。errors.Is 和 errors.As 通常是更健壮和方便的选择。

错误包装机制极大地增强了 Go 的错误处理能力，使得构建更健壮、更易于调试和维护的程序成为可能。

sync 包：性能优化与 sync.Pool 改进

Go 1.13 对 sync 包中的一些常用同步原语进行了性能优化，并改进了 sync.Pool 的行为。

锁和 Once 的性能提升

sync.Mutex（互斥锁）、sync.RWMutex（读写锁）和 sync.Once（保证函数只执行一次）是非常基础且常用的同步工具。

• sync.Mutex : 用于保护临界区，确保同一时间只有一个 goroutine 可以访问共享资源。

var mu sync.Mutex
var counter int

func increment() {
    mu.Lock() // 获取锁
    defer mu.Unlock() // 保证释放锁
    counter++
}

• sync.RWMutex : 允许多个读取者同时访问资源，但写入者必须独占访问。适用于读多写少的场景。

var rwMu sync.RWMutex
var config map[string]string

func getConfig(key string) string {
    rwMu.RLock() // 获取读锁
    defer rwMu.RUnlock() // 释放读锁
    return config[key]
}

func setConfig(key, value string) {
    rwMu.Lock() // 获取写锁
    defer rwMu.Unlock() // 释放写锁
    config[key] = value
}

• sync.Once : 用于确保某个初始化操作或其他需要只执行一次的动作，在并发环境下确实只执行一次。

var once sync.Once
var serviceInstance *Service

func GetService() *Service {
    once.Do(func() {
        // 初始化操作，只会在首次调用 Do 时执行
        serviceInstance = &Service{}
        serviceInstance.init()
    })
    return serviceInstance
}

在 Go 1.13 中，这些原语的 快速路径 (fast path) （即没有发生锁竞争或 Once.Do 已经被执行过的情况）被 内联 (inlined) 到了调用者的代码中。这意味着在最常见、性能最关键的非竞争场景下，调用这些方法的开销显著降低。根据官方说明，在 amd64 架构下：

• Mutex.Lock, Mutex.Unlock, RWMutex.Lock, RWMutex.RUnlock 的非竞争情况性能提升高达 10%。
• Once.Do 在非首次执行时（即 once 已经被触发后）的速度提升了大约 2 倍。

sync.Pool 的改进

sync.Pool 是一个用于存储和复用临时对象的技术，主要目的是减少内存分配次数和 GC 压力，尤其适用于那些需要频繁创建和销毁、生命周期短暂的对象（如网络连接的缓冲区、编解码器的状态对象等）。

var bufferPool = sync.Pool{
    New: func() interface{} {
        // New 函数用于在 Pool 为空时创建新对象
        fmt.Println("Allocating new buffer")
        return make([]byte, 4096) // 例如创建一个 4KB 的缓冲区
    },
}

func handleConnection(conn net.Conn) {
    // 从 Pool 获取一个 buffer
    buf := bufferPool.Get().([]byte)

    // 使用 buffer ...
    n, err := conn.Read(buf)
    // ...

    // 将 buffer 放回 Pool 以便复用
    // 注意：放回前最好清理一下 buffer 内容（如果需要）
    // e.g., buf = buf[:0] or zero out parts of it
    bufferPool.Put(buf)
}

Go 1.13 对 sync.Pool 做了两项重要改进：

1. 减少对 GC STW (Stop-The-World) 暂停时间的影响 ：在之前的版本中，如果 sync.Pool 中缓存了大量对象，清理这些对象（尤其是在 GC 期间）可能会对 STW 暂停时间产生比较明显的影响。Go 1.13 优化了 sync.Pool 的内部实现，使得即使池中对象很多，对 GC 暂停时间的影响也显著减小。
2. 跨 GC 保留部分对象 ：这是 sync.Pool 行为的一个重大变化。在 Go 1.13 之前， 每次 GC 运行时，sync.Pool 中的所有缓存对象都会被无条件清除 。这意味着每次 GC 之后，如果程序继续请求对象，Pool 会变空，导致大量调用 New 函数来重新填充缓存，这可能在 GC 后造成短暂的性能抖动（分配和 GC 压力增加）。

从 Go 1.13 开始，sync.Pool 可以在 GC 之后保留一部分之前缓存的对象 。它使用了一个两阶段的缓存机制，主缓存池仍然会在 GC 时被清理，但会有一个备用（受害者）缓存池保留上一次 GC 清理掉的对象，供本次 GC 后使用。这样，GC 之后 Pool 不再是完全空的，可以更快地提供缓存对象，减少了对 New 的调用频率，从而平滑了 GC 后的性能表现，降低了负载峰值。

使用 sync.Pool 的注意事项（结合 1.13 改进）

• sync.Pool 仍然适用于临时对象的复用，以减少分配和 GC 压力。
• 由于对象现在可能跨 GC 保留，从 Pool 中 Get 到的对象可能包含上次使用时残留的数据。因此，在使用前对其进行必要的 重置或清理 变得更加重要（例如，对于 []byte，使用 buf = buf[:0]；对于结构体，清零关键字段）。
• Pool 保留对象的能力并不意味着你可以用它来管理需要精确生命周期控制的资源（如文件句柄、网络连接），这些资源通常需要显式的 Close 方法。
• 虽然跨 GC 保留对象减少了冷启动开销，但也意味着 Pool 可能会持有内存更长时间。不过，Go 1.13 运行时本身也改进了内存归还给操作系统的策略，这在一定程度上平衡了这一点。

总的来说，Go 1.13 中 sync 包的改进提升了常用同步原语的性能，并使 sync.Pool 在高并发和频繁 GC 的场景下表现更加稳定和高效。