Golang怎么实现带优先级的select

这篇“golang怎么实现带优先级的select”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Golang怎么实现带优先级的select”文章吧。

背景

在 Golang 里面，我们经常使用 channel 进行协程之间的通信。这里有一个经典的场景，也就是生产者消费者模式，生产者协程不断地往 Channel 里面塞元素，而消费者协程不断地消费这些元素。

写成代码就是如下：

package mainimport ("fmt""sync""time")func main() {ch := make(chan int, 10)var wg sync.WaitGroupwg.Add(2)go producer(ch, &wg)go consumer(ch, &wg)wg.Wait()}// 生产者func producer(ch chan int, wg *sync.WaitGroup) {defer wg.Done()i := 0for {select {case ch <- i:default:// 丢弃log.Println("discard")}i++time.Sleep(time.Second)}}// 消费者func consumer(ch chan int, wg *sync.WaitGroup) {defer wg.Done()consume := func(i int) {fmt.Println(i)time.Sleep(time.Millisecond * 700)}for {i := <-chconsume(i) // 消费元素}}

生产者不断产生元素，消费者消费元素。生产者不会等待消费者消费完毕（不然可能影响其他任务），如果 channel 已经满了，也就是说明消费者消费不过来，生产者就会丢弃这个任务。

生产者平均一秒生成1个，消费者0.7秒消费一个。正常情况下消费者是消费得过来的，然而很多时候消费者协程还需要做一些定时任务，比如一些定时清理工作。假如这个清理工作每2秒触发一次，清理时间一般需要1.5秒，也就是如果每次都做每一秒有0.75秒会被清理工作占有了，但是它不是一定要非常及时的，可以等空闲时再进行。 如下代码：

// 消费者func consumer(ch chan int, wg *sync.WaitGroup) {defer wg.Done()t := time.NewTicker(time.Second * 2)consume := func(i int) {fmt.Println(i)time.Sleep(time.Millisecond * 700)}clear := func() {fmt.Println("clear")time.Sleep(time.Millisecond * 1500)}for {select {case i := <-ch:consume(i) // 消费元素:case <-t.C:clear() // 清理}}}

运行程序到第15秒的时候，生产者发现 channel满了，于是开始丢包：

0
1
clear
2
3
4
5
6
clear
7
clear
8
clear
9
clear
clear
10
clear
11
12
13
14
clear
15
clear
clear
discard
16
clear
discard
discard

解决方案

既然清理任务的优先级并不高，那么它就不应该阻塞消费元素流程，而是应该在空闲时才去执行。由于 Golang 里面，如果 select 两个 case 都同时满足，会随机选一个执行，因此第一想到的可能会使用如下代码实现优先级case：

// 消费者func consumer(ch chan int, wg *sync.WaitGroup) {defer wg.Done()t := time.NewTicker(time.Second * 2)consume := func(i int) {fmt.Println(i)time.Sleep(time.Millisecond * 700)}clear := func() {fmt.Println("clear")time.Sleep(time.Millisecond * 1500)}for {select {case i := <-ch:consume(i) // 消费元素continue   // 可能还有元素，不走清理逻辑default:}// 没有元素才走清理逻辑select {case <-t.C:clear() // 清理default:}}}

如果运行这个程序，可以发现它能够满足优先级的需求，先消费元素，空闲时再执行清理任务。

然而，在没有元素可以消费，也没有清理任务可以执行的时候，这里的for将会不断地循环，浪费CPU资源。

其实，可以使用下面的方法实现优先级case，它能够在没有元素就绪的时候阻塞在 select，而不是不断循环：

// 消费者func consumer(ch chan int, wg *sync.WaitGroup) {defer wg.Done()t := time.NewTicker(time.Second * 2)consume := func(i int) {fmt.Println(i)time.Sleep(time.Millisecond * 700)}clear := func() {fmt.Println("clear")time.Sleep(time.Millisecond * 1500)}for {select {case i := <-ch:consume(i) // 消费元素case <-t.C:priority:for { // 清理前先把元素消费完select {case i := <-ch:consume(i) // 消费元素default:break priority // 注：这里会跳过这个循环，而不是再次执行}}clear() // 清理}}}

这里的关键是在触发清理case的时候，先去把channel里面的元素消费完，再进行清理，从而保证能够留下足够的channel缓冲区给生产者放置生产的元素。

一个封装

上面那段优先级case代码其实挺常用的，但是几乎都是模板代码，特别是需要在两个地方写consume(i)，因此我们可以封装一下这段代码，方便使用，减少出错：

// 优先级select ch2 的任务先执行完毕后才会执行 ch3 里面的任务func PrioritySelect[T1, T2 any](ch2 <-chan T1, f1 func(T1), ch3 <-chan T2, f2 func(T2)) {for {select {case a := <-ch2:f1(a)case b := <-ch3:priority:for {select {case a := <-ch2:f1(a)default:break priority}}f2(b)}}}

这样，我们的消费者代码就可以简化为：

// 消费者func consumer(ch chan int, wg *sync.WaitGroup) {defer wg.Done()t := time.NewTicker(time.Second * 2)consume := func(i int) {fmt.Println(i)time.Sleep(time.Millisecond * 700)}clear := func(time.Time) {fmt.Println("clear")time.Sleep(time.Millisecond * 1500)}PrioritySelect(ch, consume, t.C, clear)}

以上就是关于“Golang怎么实现带优先级的select”这篇文章的内容，相信大家都有了一定的了解，希望小编分享的内容对大家有帮助，若想了解更多相关的知识内容，请关注编程网GO频道。