golang select 机制

最新推荐文章于 2024-09-04 17:09:34 发布

Go中国

最新推荐文章于 2024-09-04 17:09:34 发布

阅读量232

点赞数

文章标签： golang 数据库开发语言后端

原文链接：https://mp.weixin.qq.com/s?__biz=MzA4ODg0NDkzOA==&mid=2247508557&idx=1&sn=0358bc4db86ad44a5337ca1122485fe1&chksm=90211da8a75694be0d00a88dc94756fa1e64012603c07d7dca1346a260bd53180d019e201f2e&scene=126&sessionid=0

版权

来源：爱发白日梦的后端

在 Go 语言中，select 是一种用于处理多个通道操作的控制结构。它可以用于在多个通道之间进行非阻塞的选择操作。

select 语句由一系列的 case 子句组成，每个 case 子句表示一个通道操作。select 语句会按照顺序依次检查每个 case 子句，并执行其中可执行的操作。

select 的作用主要有以下几个方面：

多路复用通道

select 可以同时监听多个通道上的操作，一旦某个通道可读或可写，就会执行相应的操作。这样可以避免使用阻塞的 channel 操作，提高程序的并发性能。

package main

import (
 "fmt"
 "time"
)

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

 go func() {
  time.Sleep(2 * time.Second)
  ch1 <- 1
 }()

 go func() {
  time.Sleep(1 * time.Second)
  ch2 <- 2
 }()

 select {
 case <-ch1:
  fmt.Println("Received from ch1")
 case <-ch2:
  fmt.Println("Received from ch2")
 case <-time.After(3 * time.Second):
  fmt.Println("Timeout")
 }
}

在这个示例中，我们创建了两个通道 ch1 和 ch2。然后分别在两个 goroutine 中进行操作，通过不同的延迟时间向通道发送数据。

在 main 函数中，我们使用 select 语句同时监听 ch1 和 ch2 两个通道，并通过 <-ch1 和 <-ch2 分别接收通道中的数据。同时，我们还使用 time.After 函数设置了一个 3 秒的超时时间。

在 select 语句的执行过程中，会依次检查每个 case 子句。如果有多个 case 子句都是可执行的，select 会随机选择一个执行。在这个示例中，由于 ch2 的数据发送时间比 ch1 早，所以最终会执行 case <-ch2 分支，输出 "Received from ch2"。

如果 select 语句中的所有通道都没有数据可读，并且超过了设置的超时时间，那么就会执行 time.After 对应的 case 分支，输出 "Timeout"。

非阻塞的通道操作

select 语句中的 case 子句可以使用非阻塞的通道操作，包括发送和接收操作。如果没有可用的通道操作，select 会立即执行 default 子句（如果有），或者阻塞等待第一个可执行的操作。

package main

import (
 "fmt"
)

func main() {
 ch := make(chan int, 2)

 ch <- 1 // 向通道写入数据，此时通道未满，操作不会被阻塞
 fmt.Println("Data written to channel")

 select {
 case ch <- 2: // 尝试向已满的通道再次写入数据，由于通道已满，操作会被立即返回
  fmt.Println("Data written to channel")
 default:
  fmt.Println("Channel is full, unable to write data")
 }

 data, ok := <-ch // 尝试从通道读取数据，此时通道中有数据，操作不会被阻塞
 if ok {
  fmt.Println("Data read from channel:", data)
 }

 select {
 case data, ok := <-ch: // 尝试从空的通道读取数据，由于通道为空，操作会被立即返回
  if ok {
   fmt.Println("Data read from channel:", data)
  } else {
   fmt.Println("Channel is empty, unable to read data")
  }
 default:
  fmt.Println("Channel is empty, unable to read data")
 }
}

在这个示例中，我们首先创建了一个缓冲大小为 2 的通道 ch。然后，我们使用带缓冲的通道进行数据写入操作 ch <- 1，由于通道未满，操作不会被阻塞。

接下来，我们使用非阻塞的通道写入操作 ch <- 2，由于通道已满，操作会立即返回。我们使用 select 语句来处理这种情况，当无法进行通道写入操作时，会执行 default 分支，输出 "Channel is full, unable to write data"。

然后，我们尝试从通道中读取数据 data, ok := <-ch，由于通道中有数据，操作不会被阻塞。

最后，我们使用非阻塞的通道读取操作 data, ok := <-ch，由于通道为空，操作会立即返回。同样，我们使用 select 语句来处理这种情况，当无法进行通道读取操作时，会执行 default 分支，输出 "Channel is empty, unable to read data"。

超时处理

通过在 select 语句中结合使用 time.After 函数和通道操作，可以实现超时机制。例如，可以使用 select 监听一个带有超时的通道操作，当超过指定时间时，执行相应的操作。

package main

import (
 "fmt"
 "time"
)

func main() {
 ch := make(chan int)

 go func() {
  time.Sleep(2 * time.Second)
  ch <- 1
 }()

 select {
 case <-ch:
  fmt.Println("Received from channel")
 case <-time.After(3 * time.Second):
  fmt.Println("Timeout")
 }
}

在这个示例中，我们创建了一个通道 ch。然后，我们在一个 goroutine 中进行操作，在 2 秒后向通道发送数据 ch <- 1。

在 main 函数中，我们使用 select 语句同时监听 ch 通道和 time.After 函数返回的超时通道。超时通道是一个计时器通道，在指定的时间后会发送一个值给通道。

在 select 语句的执行过程中，会依次检查每个 case 子句。如果 ch 通道接收到了数据，就会执行 case <-ch 分支，输出 "Received from channel"。如果等待时间超过了设定的超时时间（这里是 3 秒），就会执行 time.After 对应的 case 分支，输出 "Timeout"。

在这个示例中，由于通道的发送操作需要 2 秒才能完成，而超时时间设定为 3 秒，所以最终会执行 case <-ch 分支，输出 "Received from channel"。

控制并发流程

select 可以与 goroutine 结合使用，实现对并发流程的控制。通过在 select 中使用通道操作来进行同步或通信，可以协调不同 goroutine 之间的执行顺序。

package main

import (
 "fmt"
 "sync"
)

func main() {
 var wg sync.WaitGroup

 // 设置并发任务数量
 concurrency := 3

 // 创建一个用于控制并发的通道
 semaphore := make(chan struct{}, concurrency)

 // 假设有一组任务需要并发执行
 tasks := []string{"task1", "task2", "task3", "task4", "task5"}

 // 遍历任务列表
 for _, task := range tasks {
  // 增加 WaitGroup 的计数器
  wg.Add(1)

  // 启动一个 goroutine 来执行任务
  go func(t string) {
   // 在 goroutine 开始前向通道发送一个信号
   semaphore <- struct{}{}

   // 执行任务
   fmt.Println("Executing", t)

   // 模拟任务执行时间
   // 这里可以是任何实际的任务逻辑
   // ...

   // 任务完成后从通道释放一个信号
   <-semaphore

   // 减少 WaitGroup 的计数器
   wg.Done()
  }(task)
 }

 // 等待所有任务完成
 wg.Wait()

 fmt.Println("All tasks completed")
}

在这个示例中，我们首先定义了并发任务的数量 concurrency，这决定了同时执行任务的最大数量。然后，我们创建了一个用于控制并发的通道 semaphore，通过向通道发送信号来控制并发数量。

接下来，我们定义了一组需要并发执行的任务列表 tasks。在遍历任务列表时，我们增加了 WaitGroup 的计数器，并启动一个 goroutine 来执行每个任务。

在每个任务的 goroutine 中，首先向通道 semaphore 发送一个信号，以占用一个并发槽位。然后执行任务的逻辑，这里使用了简单的输出来表示任务的执行。任务执行完毕后，从通道 semaphore 中释放一个信号，以让其他任务可以占用并发槽位。最后，减少 WaitGroup 的计数器，表示任务完成。

最后，我们使用 WaitGroup 的 Wait 方法来等待所有任务完成，确保程序在所有任务执行完毕后再继续执行。