如何使用Golang的select语句监听多个channel的事件-Golang-PHP中文网

Golang中通过select语句监听多个channel，实现并发控制、超时与非阻塞操作，并利用done channel或context.Context优雅关闭goroutine。

如何使用golang的select语句监听多个channel的事件

在Golang中，要同时监听多个channel的事件，我们主要依赖

select

登录后复制

语句。它提供了一种机制，让goroutine可以等待多个通信操作中的任意一个完成，并且是Go并发编程模型中非常核心且强大的工具。

解决方案

select

登录后复制

语句的语法结构与

switch

登录后复制

非常相似，但它的

case

登录后复制

是针对channel的发送或接收操作。当

select

登录后复制

语句执行时，它会评估所有的

case

登录后复制

表达式。如果其中一个

case

登录后复制

对应的channel操作已经准备就绪（例如，可以接收数据或者可以发送数据），那么该

case

登录后复制

就会被执行。

一个最基础的

select

登录后复制

用法是这样的：

package main

import (
    "fmt"
    "time"
)

func worker(id int, ch chan string) {
    for {
        select {
        case msg := <-ch:
            fmt.Printf("Worker %d received: %s\n", id, msg)
        case <-time.After(2 * time.Second):
            fmt.Printf("Worker %d timed out waiting for message.\n", id)
            return // 退出goroutine
        }
    }
}

func main() {
    messageChan1 := make(chan string)
    messageChan2 := make(chan string)

    go worker(1, messageChan1)
    go worker(2, messageChan2) // 实际上这里worker 2并不会收到消息，因为main只发给了messageChan1

    go func() {
        for i := 0; i < 5; i++ {
            time.Sleep(500 * time.Millisecond)
            messageChan1 <- fmt.Sprintf("Hello from main %d", i)
        }
        close(messageChan1) // 发送完毕后关闭channel
    }()

    // 给goroutines一些时间运行
    time.Sleep(5 * time.Second)
    fmt.Println("Main finished.")
}

登录后复制

在这个例子中，

worker

登录后复制

goroutine尝试从

ch

登录后复制

接收消息。如果2秒内没有消息，

time.After

登录后复制

的case就会触发，goroutine随之退出。

select

登录后复制

语句会一直阻塞，直到其中一个

case

登录后复制

准备就绪。如果多个

case

登录后复制

同时准备就绪，

select

登录后复制

会随机选择一个执行。如果没有任何

case

登录后复制

准备就绪，并且存在

default

登录后复制

语句，那么

default

登录后复制

语句会立即执行，

select

登录后复制

不会阻塞。

立即学习“go语言免费学习笔记（深入）”；

当多个Channel同时就绪时，select语句是如何选择的？

这是

select

登录后复制

语句一个非常有意思且关键的特性。当

select

登录后复制

语句中的多个

case

登录后复制

同时满足条件，也就是有多个channel都已准备好进行通信操作时，Go运行时会随机选择其中一个
case
登录后复制
来执行。它不是按照从上到下的顺序，也不是通过某种优先级机制。这种随机性设计是为了避免一些潜在的公平性问题，比如某个channel因为总是排在前面而“饿死”其他channel。

举个例子，假设你有两个channel

ch1

登录后复制

和

ch2

登录后复制

，并且它们在同一时刻都有数据可读：

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() {
        time.Sleep(100 * time.Millisecond)
        ch1 <- "From ch1"
    }()

    go func() {
        time.Sleep(100 * time.Millisecond)
        ch2 <- "From ch2"
    }()

    // 尝试多次运行，你会发现输出结果可能是 "Received From ch1" 也可能是 "Received From ch2"
    select {
    case msg1 := <-ch1:
        fmt.Println("Received", msg1)
    case msg2 := <-ch2:
        fmt.Println("Received", msg2)
    }

    time.Sleep(1 * time.Second) // 等待一下，确保goroutine有机会执行
}

登录后复制

多次运行这段代码，你会发现输出结果是不确定的，有时是

Received From ch1

登录后复制

，有时是

Received From ch2

登录后复制

。这种随机性在大多数并发场景下是可接受的，因为它确保了没有哪个channel会被永久忽略。如果你需要严格的顺序或优先级，那么

select

登录后复制

本身并不能直接提供，你可能需要引入额外的逻辑（比如计数器、状态机或者更复杂的协调机制）来管理。但通常情况下，Go的这种随机选择机制已经足够满足并发处理的需求了。

SpeakingPass-打造你的专属雅思口语语料

使用chatGPT帮你快速备考雅思口语，提升分数

查看详情

如何利用select语句实现超时控制和非阻塞操作？

select

登录后复制

语句在实现超时控制和非阻塞操作方面表现得非常出色，这得益于它能够监听多个channel事件的特性。

实现超时控制： 超时控制通常用于限制一个操作的等待时间。在

select

登录后复制

中实现超时非常简单，只需引入

time.After

登录后复制

函数返回的channel即可。

time.After(duration)

登录后复制

会返回一个channel，在

duration

登录后复制

时间过后，它会发送一个当前时间值。

package main

import (
    "fmt"
    "time"
)

func fetchResource(timeout time.Duration) (string, error) {
    dataChan := make(chan string)
    errChan := make(chan error)

    go func() {
        // 模拟一个可能耗时的网络请求或计算
        time.Sleep(timeout / 2) // 假设这个操作通常很快完成
        // time.Sleep(timeout * 2) // 模拟一个会超时的操作
        dataChan <- "Resource data loaded successfully!"
        // errChan <- fmt.Errorf("failed to load resource") // 也可以发送错误
    }()

    select {
    case data := <-dataChan:
        return data, nil
    case err := <-errChan:
        return "", err
    case <-time.After(timeout): // 超时控制
        return "", fmt.Errorf("operation timed out after %v", timeout)
    }
}

func main() {
    fmt.Println("Attempting to fetch resource with 1 second timeout...")
    data, err := fetchResource(1 * time.Second)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Success:", data)
    }

    fmt.Println("\nAttempting to fetch resource with 100 millisecond timeout (likely to timeout)...")
    data, err = fetchResource(100 * time.Millisecond)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Success:", data)
    }
}

登录后复制

在这个例子中，

fetchResource

登录后复制

函数会启动一个goroutine去加载资源。

select

登录后复制

语句会等待资源加载完成（

dataChan

登录后复制

或

errChan

登录后复制

），或者等待

time.After

登录后复制

的channel发送值，表示超时。这种模式非常适合于需要对I/O操作或远程调用设置时间限制的场景。

实现非阻塞操作： 非阻塞操作意味着如果某个channel操作当前无法完成，程序不应该等待，而是立即执行其他逻辑。这可以通过

select

登录后复制

语句的

default

登录后复制

分支来实现。如果

select

登录后复制

语句中的所有

case

登录后复制

都没有准备就绪，并且存在

default

登录后复制

分支，那么

default

登录后复制

分支会立即执行，

select

登录后复制

语句不会阻塞。

package main

import (
    "fmt"
    "time"
)
func tryReceive(ch chan string) {
    select {
    case msg := <-ch:
        fmt.Println("Received message:", msg)
    default:
        fmt.Println("No message available, continuing...")
    }
}

func main() {
    myChan := make(chan string, 1) // 创建一个带缓冲的channel

    fmt.Println("First attempt (channel is empty):")
    tryReceive(myChan) // 此时ch为空，default会执行

    myChan <- "Hello Go!" // 发送一个消息到channel

    fmt.Println("\nSecond attempt (channel has message):")
    tryReceive(myChan) // 此时ch有消息，会接收并打印

    fmt.Println("\nThird attempt (channel is empty again):")
    tryReceive(myChan) // 此时ch又空了，default会执行

    // 如果没有default，第一次和第三次调用会一直阻塞
    // 只有当channel有消息时才会解除阻塞
    time.Sleep(100 * time.Millisecond) // 稍微等待一下，确保输出顺序
}

登录后复制

default

登录后复制

分支使得

select

登录后复制

语句变成非阻塞的。这对于需要周期性检查channel状态，但又不想因此阻塞主逻辑的场景非常有用，比如在游戏循环中处理用户输入，或者在一个事件循环中尝试分发任务。但要注意，过度使用

default

登录后复制

可能会导致goroutine陷入“忙等待”状态，持续消耗CPU资源，所以要谨慎使用。

在并发编程中，如何优雅地关闭通过select监听的goroutine？

优雅地关闭通过

select

登录后复制

监听的goroutine是并发编程中一个常见的挑战，也是一个非常重要的实践，可以避免资源泄露和程序僵死。通常，我们会引入一个“完成”或“退出”信号channel，或者使用

context.Context

登录后复制

来通知goroutine停止工作。

使用“完成”Channel： 这是最直接的方式，给每个工作goroutine一个额外的channel，当需要关闭时，向这个channel发送一个信号。

package main

import (
    "fmt"
    "time"
)

func workerWithDone(id int, dataChan <-chan string, done <-chan struct{}) {
    fmt.Printf("Worker %d started.\n", id)
    for {
        select {
        case data, ok := <-dataChan:
            if !ok { // dataChan被关闭
                fmt.Printf("Worker %d: Data channel closed, exiting.\n", id)
                return
            }
            fmt.Printf("Worker %d received: %s\n", id, data)
        case <-done: // 收到关闭信号
            fmt.Printf("Worker %d received done signal, exiting gracefully.\n", id)
            return
        }
    }
}

func main() {
    dataQueue := make(chan string, 5)
    doneChan := make(chan struct{}) // 用于发送关闭信号的channel

    go workerWithDone(1, dataQueue, doneChan)

    // 主goroutine发送一些数据
    for i := 0; i < 10; i++ {
        dataQueue <- fmt.Sprintf("Task-%d", i+1)
        time.Sleep(100 * time.Millisecond)
    }

    // 模拟工作一段时间后，发送关闭信号
    fmt.Println("Main: Signaling worker to stop...")
    close(doneChan) // 关闭doneChan，所有监听它的goroutine都会收到信号

    // 也可以通过向doneChan发送一个空结构体来通知，但关闭channel是更常见的模式
    // doneChan <- struct{}{}

    // 等待worker goroutine有机会退出
    time.Sleep(500 * time.Millisecond)
    fmt.Println("Main: All done.")
}

登录后复制

这里，

workerWithDone

登录后复制

函数监听

dataChan

登录后复制

来处理数据，同时也监听

done

登录后复制

channel。当

main

登录后复制

goroutine关闭

doneChan

登录后复制

时，

workerWithDone

登录后复制

的

case <-done:

登录后复制

就会被触发，从而优雅地退出循环。需要注意的是，当

dataChan

登录后复制

被关闭时，

data, ok := <-dataChan

登录后复制

操作会返回

ok=false

登录后复制

，这也是一个退出信号。通常，我们会确保在所有数据处理完毕后才关闭

dataChan

登录后复制

，或者在

done

登录后复制

信号优先的情况下，让

done

登录后复制

信号处理退出。

使用

context.Context

登录后复制

：在更复杂的应用中，尤其是涉及多个层级或需要传递取消信号的场景，使用

context.Context

登录后复制

是更推荐的方式。

context.Context

登录后复制

提供了一个

Done()

登录后复制

方法，它返回一个channel，当Context被取消时，这个channel会关闭。

package main

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

func workerWithContext(ctx context.Context, dataChan <-chan string) {
    fmt.Println("Worker started with context.")
    for {
        select {
        case data, ok := <-dataChan:
            if !ok {
                fmt.Println("Worker: Data channel closed, exiting.")
                return
            }
            fmt.Printf("Worker received: %s\n", data)
        case <-ctx.Done(): // 监听context的取消信号
            fmt.Println("Worker received context cancellation, exiting gracefully.")
            // 可以在这里进行一些清理工作
            return
        }
    }
}

func main() {
    dataQueue := make(chan string, 5)
    ctx, cancel := context.WithCancel(context.Background()) // 创建一个可取消的context

    go workerWithContext(ctx, dataQueue)

    // 主goroutine发送一些数据
    for i := 0; i < 10; i++ {
        dataQueue <- fmt.Sprintf("Task-%d", i+1)
        time.Sleep(100 * time.Millisecond)
    }

    // 模拟工作一段时间后，取消context
    fmt.Println("Main: Canceling context to stop worker...")
    cancel() // 发送取消信号

    // 等待worker goroutine有机会退出
    time.Sleep(500 * time.Millisecond)
    fmt.Println("Main: All done.")
}

登录后复制