1
// 在 Intel Ice Lake、AMD Zen 4+ 等平台
2
// GC 扫描利用 AVX-512 指令
3
// 进一步减少 10% GC 开销

1
// 如遇问题可禁用
2
import "os"
3
os.Setenv("GODEBUG", "nogreenteagc=1")
4

5
// 或在构建时
6
// go build -tags=nogreenteagc

1
// GC 行为变化
2
// - 标记更高效
3
// - 扫描更并行
4
// - Stop The World 时间更短
5

6
// 用户代码无需修改
7
// GC 内部优化对应用透明

1
import "runtime"
2

3
func main() {
4
    // 每次运行 heap 基址不同
5
    // 防止攻击者预测内存布局
6

7
    // heap 随机化范围
8
    // - 64 位平台
9
    // - 每次启动使用不同的 heap 基址
10
    // - 有效防止 heap 喷射攻击
11
}

1
// 内存地址每次运行不同
2
ptr := make([]byte, 100)
3
fmt.Printf("%p\n", ptr) // 每次输出不同
4

5
// 但同一运行内地址稳定

1
// 仅用于调试
2
import "os"
3
os.Setenv("GOEXPERIMENT", "norandomizedheapbase64")

1
# 新的 go fix 命令
2
go fix ./...
3

4
# 列出可用修复
5
go fix -l
6

7
# 应用特定修复
8
go fix -r jsonnumber ./...
9

10
# 预览 diff
11
go fix -d ./...

1
# 可修复的项目示例
2
go fix -r newapi ./...
3
# - 使用 context.Context
4
# - 使用 io.Discard 替代 nil
5
# - 使用 slices 包替代 sort 包
6

7
go fix -r httpreplace ./...
8
# - 替换 net/http 函数

1
// 定义自定义 fix
2
//go:fix oldpkg
3
//go:fix newpkg
4

5
func init() {
6
    // 注册修复逻辑
7
    fix.Register("oldfunc", func(fix *fix.Cursor) {
8
        fix.Replace("oldpkg.OldFunc", "newpkg.NewFunc")
9
    })
10
}

1
import (
2
    "runtime/pprof"
3
    "net/http"
4
    _ "net/http/pprof"
5
)
6

7
func init() {
8
    // 启用 leak profile
9
    // 访问 /debug/pprof/goroutineleak
10
}
11

12
// 检测算法：
13
// 1. 查找阻塞在 sync primitive 上的 goroutine
14
// 2. 验证其等待的 primitive 是否不可达
15
// 3. 不可达的 goroutine 即为 leaked

1
// 在测试中检测 goroutine 泄漏
2
import "testing"
3

4
func TestLeak(t *testing.T) {
5
    // 启用泄漏检测
6
    // 测试结束后报告 leaked goroutine
7

8
    // 运行测试
9
    t.Parallel()
10

11
    // 如果有泄漏，测试失败
12
}

1
// 场景1：未关闭的 channel
2
func leaky() {
3
    ch := make(chan int)
4
    // 发送后忘记关闭
5
    ch <- 1
6
    // channel 无法被 GC
7
}
8

9
// 场景2：sync.Mutex 未解锁
10
func leaky2() {
11
    var mu sync.Mutex
12
    mu.Lock()
13
    // 提前 return，忘记 Unlock
14
    return
15
    mu.Unlock()
16
}
17

18
// 场景3：time.Timer 未停止
19
func leaky3() {
20
    timer := time.NewTimer(time.Hour)
21
    // 提前返回，timer 泄漏
22
    return
23
}

1
// 旧语法
2
ptr := new(int)
3
*ptr = 42
4

5
// Go 1.26 可以这样用：
6
// new(T) 返回 *T
7
// 初始化为零值
8

9
// 组合用法（结合泛型）
10
func Make[T any]() *T {
11
    return new(T)  // 语法更自然
12
}

1
// 更优雅的泛型工厂函数
2
type Pool[T any] struct {
3
    item T
4
}
5

6
func (p *Pool[T]) Get() *T {
7
    if p.item == nil {
8
        p.item = new(T)  // 清晰明了
9
    }
10
    return p.item
11
}

1
import "crypto/hpke"
2

3
// 创建发送方
4
sender, err := hpke.NewSender(
5
    pkR,           // 接收方公钥
6
    []byte("demo"), // info
7
    hpke.AES128GCM,
8
)
9

10
// 加密消息
11
ct, seed, err := sender.Seal([]byte("message"))

1
// 端到端加密
2
// 混合加密（非对称 + 对称）
3
// 前向保密

1
import "simd/archsimd"
2

3
// 当前支持：amd64
4
// 提供 128/256/512 位向量类型

1
import "simd/archsimd"
2

3
func SIMDAdd() {
4
    // 128 位向量：4 x float32
5
    a := archsimd.Float32x4{1, 2, 3, 4}
6
    b := archsimd.Float32x4{5, 6, 7, 8}
7

8
    c := a.Add(b)  // {6, 8, 10, 12}
9

10
    // 256 位向量：8 x float32 或 4 x float64
11
    d := archsimd.Float32x8{}
12

13
    // 512 位向量：16 x float32
14
    e := archsimd.Float32x16{}
15
}

1
// 算术
2
v1.Add(v2)
3
v1.Sub(v2)
4
v1.Mul(v2)
5

6
// 比较
7
v1.Eq(v2)
8
v1.Lt(v2)
9

10
// 内存操作
11
v1.Load(ptr)
12
v1.Store(ptr, v1)
13

14
// 特定操作
15
v1.Shuffle(v2)
16
v1.UnpackHi()
17
v1.UnpackLo()

1
// 实验性：安全清除临时数据
2
import "runtime/secret"
3

4
func CryptoOp(key []byte) {
5
    // 使用后清除
6
    defer secret.Erase(key)
7

8
    // ... 使用 key ...
9
    // 函数返回时 key 被清除
10
}

1
# go 1.26.x 创建 go.mod
2
# 使用 go 1.25.0
3

4
# go 1.27rc1 创建 go.mod
5
# 使用 go 1.26.0

1
# 默认显示 flame graph
2
# 可在 View 菜单切换回 graph

1
// sync.Mutex 内部优化
2
// 减少自旋开销
3
// 提高高并发性能

1
// 以下设置已弃用
2
// asynctimerchan - Timer 行为
3
// gotypesalias - 类型别名
4
// randseednop - 随机种子
5
// netdns - DNS 行为

1
# Go 1.25 是最后一个支持 windows-arm 的版本
2
# Go 1.26 已移除