Go语言中select语句的default行为解析与非阻塞模式实现

select {
case msg := <-ch1:
    fmt.Println("Received from ch1:", msg)
case <-time.After(time.Second): // 1秒后超时
    fmt.Println("Timeout on ch2")
default:
    // 如果ch1未就绪且未超时，则执行此空操作并立即继续
    // 类似于Python的pass
    // fmt.Println("No channel ready, continuing...") // 也可以选择打印日志
}
fmt.Println("Execution continues immediately after select.")

package main

import (
    "fmt"
    "time"
)

func worker(id int, quit <-chan bool) {
    i := 0
    for {
        select {
        case quit_status := <-quit:
            if quit_status == true {
                fmt.Printf("********************* GOROUTINE [%d] Received QUIT MSG\n", id)
                return // 收到退出信号，终止goroutine
            }
        // 注意：此处没有default子句
        }
        // 如果quit通道没有信号，此select语句会一直阻塞
        // 直到quit通道有数据或者被关闭
        fmt.Printf("GOROUTINE [%d] is still running, waiting for quit signal. Step: %d\n", id, i)
        i++
        time.Sleep(500 * time.Millisecond) // 模拟工作
    }
}

func main() {
    quit := make(chan bool)
    go worker(1, quit)

    fmt.Println("Main goroutine is working...")
    time.Sleep(3 * time.Second) // 主goroutine工作一段时间

    fmt.Println("Main goroutine sending QUIT signal...")
    quit <- true // 发送退出信号

    time.Sleep(1 * time.Second) // 等待worker goroutine退出
    fmt.Println("Main goroutine finished.")
}

package main

import (
    "fmt"
    "time"
)

func nonBlockingWorker(id int, quit <-chan bool) {
    i := 0
    for {
        select {
        case quit_status := <-quit:
            if quit_status == true {
                fmt.Printf("********************* GOROUTINE [%d] Received QUIT MSG\n", id)
                return
            }
        default:
            // 如果quit通道未就绪，则立即执行此处的代码
            // 实现了非阻塞检查
            fmt.Printf("GOROUTINE [%d] step: %d, NO QUIT MSG (non-blocking check)\n", id, i)
        }
        // 无论select是否从quit接收到数据，都会立即执行到这里
        i++
        time.Sleep(100 * time.Millisecond) // 模拟轻量级工作或避免忙循环
    }
}

func main() {
    quit := make(chan bool)
    go nonBlockingWorker(2, quit)

    fmt.Println("Main goroutine is working, non-blocking worker running...")
    time.Sleep(2 * time.Second) // 主goroutine工作一段时间

    fmt.Println("Main goroutine sending QUIT signal...")
    quit <- true

    time.Sleep(1 * time.Second)
    fmt.Println("Main goroutine finished.")
}

package main

import (
    "fmt"
    "time"
)

func main() {
    quit := make(chan bool)
    done := make(chan bool) // 用于通知主协程异步操作已完成

    fmt.Println("Main goroutine starts. Launching async channel monitor...")

    // 将select语句放入一个新的goroutine中
    go func() {
        defer func() {
            fmt.Println("Async monitor goroutine exited.")
            done <- true // 通知主协程异步操作已完成
        }()

        i := 0
        for {
            select {
            case quit_status := <-quit:
                if quit_status == true {
                    fmt.Printf("********************* ASYNC MONITOR RECEIVED QUIT MSG\n")
                    return // 收到退出信号，终止此goroutine
                }
            default:
                // 异步监控器可以执行一些非阻塞的检查或工作
                // 这里的default确保了即使没有quit信号，goroutine也能继续执行
                fmt.Printf("ASYNC MONITOR step: %d, NO QUIT MSG (non-blocking check)\n", i)
                time.Sleep(200 * time.Millisecond) // 模拟异步工作
            }
            i++
        }
    }()

    // 主协程立即继续执行，不会等待上面的goroutine
    fmt.Println("Main goroutine continues immediately after launching async monitor.")
    fmt.Println("Main goroutine is performing other tasks...")
    time.Sleep(3 * time.Second) // 主协程执行其他任务

    fmt.Println("Main goroutine sending QUIT signal to async monitor...")
    quit <- true // 发送退出信号

    <-done // 等待异步监控器goroutine完成
    fmt.Println("Main goroutine finished, async monitor confirmed exited.")
}