深入理解Go语言中Goroutine与操作系统线程的关联及线程创建策略

package main

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

func main() {
    // 获取并打印当前的GOMAXPROCS值
    fmt.Printf("Initial GOMAXPROCS: %d\n", runtime.GOMAXPROCS(0))

    // 设置GOMAXPROCS为1
    runtime.GOMAXPROCS(1)
    fmt.Printf("New GOMAXPROCS: %d\n", runtime.GOMAXPROCS(0))

    // 启动多个goroutine执行CPU密集型任务
    for i := 0; i < 10; i++ {
        go func(id int) {
            sum := 0
            for j := 0; j < 1e7; j++ { // 模拟CPU密集型计算
                sum += j
            }
            fmt.Printf("Goroutine %d finished calculation. Sum: %d\n", id, sum)
        }(i)
    }

    // 等待goroutines完成
    time.Sleep(2 * time.Second)
    fmt.Println("All goroutines launched.")
}

package main

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

func main() {
    runtime.GOMAXPROCS(1) // 强制只使用一个OS线程执行Go代码
    fmt.Printf("Current GOMAXPROCS: %d\n", runtime.GOMAXPROCS(0))

    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Printf("Goroutine %d: Starting (on OS thread %d)\n", id, runtime.NumGoroutine()) // NumGoroutine is not thread ID
            // 模拟一个channel阻塞操作
            ch := make(chan struct{})
            go func() {
                time.Sleep(50 * time.Millisecond) // 模拟异步操作
                close(ch)
            }()
            <-ch // Goroutine在此阻塞，但不会占用OS线程
            fmt.Printf("Goroutine %d: Finished channel wait\n", id)

            // 模拟一个sleep操作
            time.Sleep(50 * time.Millisecond) // Goroutine在此阻塞，但不会占用OS线程
            fmt.Printf("Goroutine %d: Finished sleep\n", id)
        }(i)
    }
    wg.Wait()
    fmt.Println("All goroutines finished.")
}

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "runtime"
    "sync"
    "time"
)

// #include <unistd.h> // For sleep
// void c_sleep(int seconds) {
//     sleep(seconds);
// }
import "C"

func main() {
    runtime.GOMAXPROCS(1) // 强制只使用一个OS线程执行Go代码
    fmt.Printf("Current GOMAXPROCS: %d\n", runtime.GOMAXPROCS(0))

    var wg sync.WaitGroup
    wg.Add(2)

    // Goroutine 1: 模拟阻塞式系统调用 (读取/dev/random)
    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 1: Starting blocking syscall (reading /dev/random)...")
        // 注意: /dev/random在某些系统上可能会阻塞，直到有足够的熵
        // 在Windows上，可以尝试其他阻塞文件I/O，如等待管道输入
        file, err := os.Open("/dev/random") // 这是一个可能阻塞的系统调用
        if err != nil {
            fmt.Printf("Goroutine 1: Error opening /dev/random: %v\n", err)
            return
        }
        defer file.Close()

        buffer := make([]byte, 1)
        _, err = file.Read(buffer) // 此处可能导致OS线程阻塞
        if err != nil {
            fmt.Printf("Goroutine 1: Error reading /dev/random: %v\n", err)
            return
        }
        fmt.Println("Goroutine 1: Finished blocking syscall.")
    }()

    // Goroutine 2: 模拟CGO阻塞调用
    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 2: Starting blocking CGO call...")
        C.c_sleep(1) // 调用C函数，该函数会阻塞其所在的OS线程
        fmt.Println("Goroutine 2: Finished blocking CGO call.")
    }()

    // 观察OS线程数量的变化
    go func() {
        for i := 0; i < 5; i++ {
            time.Sleep(200 * time.Millisecond)
            // NumCPU不是线程数，NumGoroutine是goroutine数。
            // 无法直接在Go代码中获取当前OS线程数，但可以通过系统工具观察。
            // 期望在阻塞期间，OS线程数会增加。
            fmt.Printf("Current Go routines: %d\n", runtime.NumGoroutine())
        }
    }()

    wg.Wait()
    fmt.Println("All blocking goroutines finished.")
    time.Sleep(1 * time.Second) // 留一些时间让运行时清理
}