Go语言中忙等待协程与超时机制的调度问题及解决方案

package main

import (
    "fmt"
    "time"
)

func main() {
    // 案例1: 休眠协程与超时
    sleepChan := make(chan int)
    go sleep(sleepChan)
    select {
    case sleepResult := <-sleepChan:
        fmt.Println(sleepResult)
    case <-time.After(time.Second):
        fmt.Println("timed out (sleep)")
    }

    // 案例2: 忙等待协程与超时
    busyChan := make(chan int)
    go busyWait(busyChan)
    select {
    case busyResult := <-busyChan:
        fmt.Println(busyResult)
    case <-time.After(time.Second):
        fmt.Println("timed out (busy-wait)")
    }
}

func sleep(c chan<- int) {
    time.Sleep(10 * time.Second) // 模拟长时间操作
    c <- 0
}

func busyWait(c chan<- int) {
    for {
        // 纯粹的忙等待，不释放CPU
    }
    c <- 0 // 永远不会执行到
}

package main

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

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

    // 设置GOMAXPROCS为机器的CPU核心数
    runtime.GOMAXPROCS(runtime.NumCPU())
    fmt.Printf("Set GOMAXPROCS to: %d\n", runtime.GOMAXPROCS(0))

    // 案例1: 休眠协程与超时
    sleepChan := make(chan int)
    go sleep(sleepChan)
    select {
    case sleepResult := <-sleepChan:
        fmt.Println(sleepResult)
    case <-time.After(time.Second):
        fmt.Println("timed out (sleep)")
    }

    // 案例2: 忙等待协程与超时
    busyChan := make(chan int)
    go busyWait(busyChan)
    select {
    case busyResult := <-busyChan:
        fmt.Println(busyResult)
    case <-time.After(time.Second):
        fmt.Println("timed out (busy-wait)")
    }
}

func sleep(c chan<- int) {
    time.Sleep(10 * time.Second)
    c <- 0
}

func busyWait(c chan<- int) {
    for {
        // 纯粹的忙等待
    }
    c <- 0
}

Initial GOMAXPROCS: 1  // 如果是Go 1.5之前的版本或显式设置为1
Set GOMAXPROCS to: 4
timed out (sleep)
timed out (busy-wait)

package main

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

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU()) // 确保多处理器可用

    // 使用Context中断忙等待协程
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel() // 确保在main函数退出时取消context

    busyChan := make(chan int)
    go interruptibleBusyWait(ctx, busyChan)

    select {
    case busyResult := <-busyChan:
        fmt.Println(busyResult)
    case <-ctx.Done(): // 监听Context的取消信号
        fmt.Println("timed out (interruptible busy-wait) via context")
    }

    // 给协程一些时间清理
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Main function finished.")
}

func interruptibleBusyWait(ctx context.Context, c chan<- int) {
    fmt.Println("Interruptible busy-wait goroutine started.")
    for {
        select {
        case <-ctx.Done(): // 检查取消信号
            fmt.Println("Interruptible busy-wait goroutine received cancellation, exiting.")
            return // 退出协程
        default:
            // 模拟一些计算密集型工作
            // 实际应用中这里可以放置业务逻辑
        }
    }
    // c <- 0 // 永远不会执行到，因为协程会提前退出
}