Golang怎么实现带优先级的select

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

背景

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

写成代码就是如下：

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	ch := make(chan int, 10)
	var wg sync.WaitGroup
	wg.Add(2)
	go producer(ch, &wg)
	go consumer(ch, &wg)
	wg.Wait()
}

// 生产者
func producer(ch chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	i := 0
	for {
		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 := <-ch
		consume(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”这篇文章的内容，相信大家都有了一定的了解，希望小编分享的内容对大家有帮助，若想了解更多相关的知识内容，请关注亿速云行业资讯频道。