深入理解 Go select 语句：default 的作用及阻塞与非阻塞模式

package main

import (
    "fmt"
    "time"
)

func main() {
    quit := make(chan bool)
    id := 1
    i := 0

    for {
        select {
        case quit_status := <-quit:
            // 假设 quit 通道在某个条件满足时发送 true
            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\n", id, i)
            i++
            time.Sleep(100 * time.Millisecond) // 模拟一些工作
        }

        if i > 5 {
            // 模拟在达到某个步数后发送退出信号
            // 注意：这里只是模拟，实际应用中 quit 通常由另一个 goroutine 关闭或发送
            // 为了演示，我们直接关闭通道，或者发送一个值
            if i == 6 {
                // quit <- true // 也可以发送一个值
            }
        }
    }
}

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 通道发送消息，或者程序退出。
        // 下面的代码将不会被执行，除非 quit 通道有消息。

        // 为了演示阻塞，我们不会在这里添加其他代码，因为它们不会被执行
        // 如果需要定期执行其他任务，请考虑使用 default 或将其放入另一个 goroutine
        fmt.Printf("GOROUTINE [%d] is still running, waiting for quit signal.\n", id) // 这行代码实际上不会被执行
        i++
    }
}

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

    fmt.Println("Main Goroutine: Worker started, waiting for 2 seconds...")
    time.Sleep(2 * time.Second) // 主 Goroutine 等待 2 秒

    fmt.Println("Main Goroutine: Sending quit signal to worker.")
    quit <- true // 发送退出信号

    time.Sleep(100 * time.Millisecond) // 给予 worker Goroutine 足够时间处理退出信号
    fmt.Println("Main Goroutine: Program finished.")
}

package main

import (
    "fmt"
    "time"
)

func main() {
    dataChan := make(chan string)
    quitChan := make(chan bool)
    counter := 0

    go func() {
        // 模拟数据在 3 秒后到达
        time.Sleep(3 * time.Second)
        dataChan <- "Hello from dataChan!"
    }()

    go func() {
        // 模拟退出信号在 5 秒后到达
        time.Sleep(5 * time.Second)
        quitChan <- true
    }()

    for {
        select {
        case data := <-dataChan:
            fmt.Printf("Received data: %s\n", data)
        case <-quitChan:
            fmt.Println("Received quit signal. Exiting.")
            return // 收到退出信号，程序终止
        default:
            // 如果没有通道就绪，则执行此块，不阻塞
            fmt.Printf("No channel ready. Continuing main loop. Counter: %d\n", counter)
            counter++
            time.Sleep(500 * time.Millisecond) // 模拟执行其他任务
        }
    }
}

package main

import (
    "fmt"
    "time"
)

func main() {
    quit := make(chan bool)
    data := make(chan string)

    // 将 select 逻辑放入一个独立的 Goroutine
    go func() {
        id := 1
        i := 0
        for {
            select {
            case quit_status := <-quit:
                if quit_status == true {
                    fmt.Printf("********************* Background Goroutine [%d] Received QUIT MSG\n", id)
                    return // 退出后台 Goroutine
                }
            case msg := <-data:
                fmt.Printf("Background Goroutine [%d] Received Data: %s\n", id, msg)
            default:
                // 如果没有通道就绪，执行非阻塞操作
                fmt.Printf("Background Goroutine [%d] step: %d, NO MSG\n", id, i)
                i++
                time.Sleep(200 * time.Millisecond) // 模拟后台工作
            }
        }
    }()

    // 主 Goroutine 立即继续执行
    fmt.Println("Main Goroutine: Execution continues immediately.")
    time.Sleep(1 * time.Second) // 主 Goroutine 模拟做其他事情

    data <- "First message" // 发送数据到后台 Goroutine
    time.Sleep(1 * time.Second)
    data <- "Second message"
    time.Sleep(1 * time.Second)

    fmt.Println("Main Goroutine: Signaling background Goroutine to quit.")
    quit <- true // 发送退出信号给后台 Goroutine

    time.Sleep(500 * time.Millisecond) // 给予后台 Goroutine 处理退出信号的时间
    fmt.Println("Main Goroutine: Program finished.")
}