Go 1.2 相比 Go1.1 有哪些值得注意的改动？

package main

type T struct {
    X [1 << 24]byte // 一个非常大的数组，导致 Field 偏移量很大
    Field int32
}

func main() {
    var x *T // x 是 nil
    // 在 Go 1.2 之前，这行代码可能不会 panic
    // 它会尝试访问地址 0 + offset(Field) (即 1<<24)
    // 这可能会访问到非法的内存区域，或者恰好访问到其他数据
    // _ = x.Field 
    
    // 在 Go 1.2 及之后，对 nil 指针 x 的 .Field 操作保证会 panic
    // fmt.Println(x.Field) // 这行会触发 panic: runtime error: invalid memory address or nil pointer dereference
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

var p *struct{ v int } // p is nil
// _ = p.v // 会 panic

var a *[5]int // a is nil
// _ = (*a)[0] // 会 panic
1.
2.
3.
4.
5.

var s []int // s is nil
// _ = len(s) // OK, returns 0
// _ = cap(s) // OK, returns 0
// _ = s[0]   // 会 panic: index out of range [0] with length 0 (注意：这里 panic 的原因是 index out of range, 但根本原因是 slice 为 nil 没有底层数组)
// _ = s[:]   // 不会 panic, 结果仍是 nil slice
1.
2.
3.
4.
5.

var i interface{} // i is nil
// _, ok := i.(int) // 不会 panic, ok 会是 false
// _ = i.(int)      // 会 panic: interface conversion: interface {} is nil, not int
1.
2.
3.

type MyStruct struct { field int }
func (m *MyStruct) PtrMethod() { 
  // fmt.Println(m.field) // 如果取消注释这行，调用 nil 接收者的 PtrMethod 会 panic
} 
func (m MyStruct) ValMethod() {} // 值接收者

func main() {
  var ms *MyStruct // ms is nil
  ms.PtrMethod() // Go 1.2 及之后，即使方法体为空，也可能因运行时检查而 panic（具体行为可能演变，但访问字段一定会 panic）
  // ms.ValMethod() // 编译错误：cannot call pointer method ValMethod on *MyStruct
                 // 注意：不能直接在 nil 指针上调用值接收者方法
                 // 如果是 var i MyInterface = ms; i.ValMethod() 这样通过接口调用，则会 panic
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

package main

import (
 "fmt"
 "runtime"
 "time"
)

func busyLoop() {
 for {
  // 纯计算，没有函数调用、系统调用或通道操作
 }
}

// 一个简单的非内联函数
//go:noinline
func someWork() {
 // 做一些微不足道的事情，关键是它是一个函数调用
}

func busyLoopWithFuncCall() {
 for {
  someWork() // 每次循环都调用一个函数
 }
}

func main() {
 runtime.GOMAXPROCS(1) // 限制只有一个操作系统线程执行 Go 代码

 go func() {
  fmt.Println("另一个 Goroutine 开始")
  time.Sleep(1 * time.Second) // 等待一秒
  fmt.Println("另一个 Goroutine 结束")
 }()

 fmt.Println("启动繁忙循环 Goroutine")
 // 在 Go 1.1 中，如果运行 busyLoop()，"另一个 Goroutine 结束" 可能永远不会打印
 // go busyLoop() 

 // 在 Go 1.2 中，运行 busyLoopWithFuncCall()，另一个 Goroutine 可以被调度执行
 go busyLoopWithFuncCall() 

 // 给另一个 goroutine 足够的时间运行和打印
 time.Sleep(2 * time.Second) 
 fmt.Println("主 Goroutine 结束")
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.

package main

import (
    "fmt"
    "runtime"
    "runtime/debug" // 需要导入以使用 SetMaxThreads
    "sync"
    "time"
)

// 一个永远阻塞的 goroutine，模拟长时间系统调用
func blockingGoroutine(wg *sync.WaitGroup) {
    defer wg.Done()
    select {} // 永久阻塞
}

func main() {
    // 在 Go 1.2 或更高版本中，可以取消注释来调整线程限制
    // ok := debug.SetMaxThreads(15000)
    // if !ok {
    //  fmt.Println("Failed to set max threads")
    // }

    numGoroutines := 11000 // 设置一个大于默认限制 10000 的数量
    var wg sync.WaitGroup

    fmt.Printf("Attempting to start %d blocking goroutines...\n", numGoroutines)

    startTime := time.Now()
    createdCount := 0
    for i := 0; i < numGoroutines; i++ {
        wg.Add(1)
        go blockingGoroutine(&wg)
        createdCount++
        // 在 Go 1.2 中，当运行时需要创建第 10001 个线程时，很可能会 panic
        // 为了更容易观察到效果，可以稍微减慢 goroutine 创建速度
        if i%500 == 0 && i > 0 {
            fmt.Printf("Started %d goroutines\n", i)
            time.Sleep(10 * time.Millisecond) 
        }
    }
    // 执行到这里所需的时间和是否能到达这里，在两个版本下可能不同
    fmt.Printf("Finished requesting %d goroutines after %v\n", createdCount, time.Since(startTime))

    // 模拟程序继续运行
    time.Sleep(5 * time.Second) 
    fmt.Println("Program finished (or survived).")
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.

package main

import (
    "fmt"
    "runtime/debug" // 需要导入以使用 SetMaxStack (Go 1.2+)
    "time"
)

// 无限递归函数，每次调用会消耗一些栈空间
func infiniteRecursion(depth int) {
    var space [1024]byte // 模拟栈上分配一些空间
    _ = space            // 防止编译器优化掉
    if depth%1000 == 0 { // 每隔1000层打印一次深度
        fmt.Printf("Recursion depth: %d\n", depth)
    }
    infiniteRecursion(depth + 1)
}

func main() {
    // 在 Go 1.2 或更高版本中，可以取消注释来设置一个更小的栈限制，以便更快看到效果
    // debug.SetMaxStack(2 * 1024 * 1024) // 设置为 2MB

    fmt.Println("Starting infinite recursion...")
    go infiniteRecursion(0)

    // 保持主 goroutine 运行，以便观察另一个 goroutine 的行为
    time.Sleep(10 * time.Second) 
    fmt.Println("Main finished (likely the recursive goroutine crashed/panicked).")
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.

package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

func idleWorker(wg *sync.WaitGroup) {
    defer wg.Done()
    time.Sleep(10 * time.Second) // 保持 goroutine 活跃但不做太多事
}

func main() {
    numGoroutines := 50000 // 创建大量 goroutine
    var wg sync.WaitGroup
    wg.Add(numGoroutines)

    fmt.Printf("Starting %d idle goroutines...\n", numGoroutines)
    startTime := time.Now()
    for i := 0; i < numGoroutines; i++ {
        go idleWorker(&wg)
    }
    fmt.Printf("Finished starting goroutines after %v\n", time.Since(startTime))

    // 尝试获取内存统计信息
    runtime.GC() // 建议进行 GC 以获得更稳定的内存读数
    var memStats runtime.MemStats
    runtime.ReadMemStats(&memStats)
    // Sys 是从 OS 获取的总内存，HeapAlloc 是堆上分配的内存
    // Goroutine 栈不直接计入 HeapAlloc，但会计入 Sys
    fmt.Printf("Memory Sys: %d MiB, HeapAlloc: %d MiB\n", memStats.Sys / 1024 / 1024, memStats.HeapAlloc / 1024 / 1024)

    // 等待所有 goroutine 完成（在这个例子中意义不大，因为它们只是 sleep）
    // wg.Wait() 
    fmt.Println("Program finished.")
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.