Asynq包

今天晚上，突然想代码实现一下asynq的小demo，问了问GPT关于Asynq的使用，结合以前看到的文章。

Asynq是Go的一个包，可用作消息队列，延时任务。市面上实现消息队列，延时队列的技术有很多，rabbitmq,kafka等，但asynq底层使用的是redis作为存储，相比于使用rabbitmq,kafka，可以少维护一个中间件，所以我们此处来学习如何使用asynq。

废话不多说，我们来使用！！！

----------------------------------------------------------------------------------------------------------------------------

asynq的几个概念首先要明白：

任务：Task，客户端会发送任务到队列，任务包含任务类型和负载数据payload。

队列：Task会被发送到队列，队列收到Task会通知任务处理器，任务处理器根据任务的类型选择对应的任务处理函数处理任务。

任务处理器：任务处理函数的集合，需要将任务类型和对应的任务处理函数注册到任务处理器。

任务处理函数：不同的任务类型对应不同的任务处理函数，任务处理函数需要自行实现。

客户端：客户端创建Task，发送Task给队列。

此图形象。

-------------------------------------------------------------------------------------------------------------------------

一：任务处理器/ 任务处理函数/ 队列

 1.首先创建一个任务处理器，即asynq.NewServer()

参数Queues：此处指定了三个队列，三个队列的名称和优先级如图所示，优先级高的队列中的任务会优先被任务处理器处理。不指定该参数，默认只会创建一个defult队列。

参数Concurrency：最大同时执行任务数。

 2.然后我们将 任务类型 和 任务处理函数 注册到了任务处理器，此处我们定义了两种任务类型，分别为my_task1和my_task2。然后启动任务处理器。

3.两个任务处理函数，这里的逻辑只是做了简单的输出。 

************以上为任务处理器的实现，如果有多个任务类型和对应的任务处理函数**************

*********************************同样可以注册到任务处理函数*********************************

------------------------------------------------------------------------------------------------------------------------------

二：任务

 

 4.此处我们创建了两个任务，NewTask时需要指定任务的类型（我们上文创建了两种任务类型），负载数据。任务创建好后将器推送入队，推送入队时可以指定延迟时间，指定延迟时间后，任务会被立刻推入队列，但会延迟执行。可以指定任务要推入哪个队列（上述创建了三种优先级不同的队列），任务进入不同的优先级队列，某种情况下，任务执行的优先级就会不同。

 上述为入队函数的实现，参数time为可选参数，有值时为延时任务，没有传值时为普通任务。

-----------------------------------------------------------------------------------------------------------------------

到此，延时任务的实现就基本完成了，下面是完整代码：

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/hibiken/asynq"
	"time"
)

// 任务类型 Tasktype
var (
	TaskType1 = "发送短信通知"
	TaskType2 = "问好"
)

// 任务处理函数
func myTask1Handler(ctx context.Context, t *asynq.Task) error {
	fmt.Println("I am TaskHandler1,receive data: ", string(t.Payload()))
	return nil
}

// 可以针对不同的Task编写不同的TaskHandler
// 不同的任务类型对应着不同的任务处理函数
func myTask2Handler(ctx context.Context, t *asynq.Task) error {
	fmt.Println("I am TaskHandler2,receive data:", string(t.Payload()))
	return nil
}

func main() {
	// 创建 asynq 任务处理器
	srv := asynq.NewServer(
		asynq.RedisClientOpt{
			Addr: "127.0.0.1:6379",
		},
		asynq.Config{
			Concurrency: 10, // 同时处理任务的最大数量
			Queues: map[string]int{ // 任务处理器会优先处理具有更高权重的队列中的任务
				"critical": 6, // 设置了3个队列，分别指定了不同的优先级
				"default":  3,
				"low":      1,
			},
		})

	// 注册任务处理函数到任务处理器   参数：任务类型   对应的处理函数
	mux := asynq.NewServeMux()
	mux.HandleFunc(TaskType1, myTask1Handler)
	mux.HandleFunc(TaskType2, myTask2Handler)

	// 启动一个groutine来启动任务处理器，因为Run()方法会阻塞，
	// 若不使用grountone，会阻塞main函数后续程序运行
	go func() {
		// 启动任务处理器
		err := srv.Run(mux)
		if err != nil {
			fmt.Println("启动任务处理器错误")
			return
		}
	}()

	// 创建一个任务Task   参数： 任务类型     payload负载数据
	// my_task1任务将被推送到critical队列，通过指定任务的队列，来间接指定任务的优先级
	my_payload1, _ := json.Marshal("要给发送信息通知的人的id为001")
	my_task1 := asynq.NewTask(TaskType1, my_payload1, asynq.Queue("critical"))

	my_payload2, _ := json.Marshal("向用户002用户问好")
	my_task2 := asynq.NewTask(TaskType2, my_payload2, asynq.Queue("low"))

	// 将任务推送入队列，设置延时时间
	err := Enq(my_task1, 2*time.Minute)
	if err != nil {
		return
	}
	err = Enq(my_task2, 1*time.Minute)
	if err != nil {
		return
	}

	defer srv.Shutdown()
	// 阻塞main函数，避免立马执行完结束
	select {}
}

// Enq 推送消息入队 参数一：Task 参数二：可选参数，延迟时间
func Enq(t *asynq.Task, time ...time.Duration) error {

	// 创建一个推送消息入队的客户端
	client := asynq.NewClient(asynq.RedisClientOpt{
		Addr: "127.0.0.1:6379",
	})
	defer client.Close()

	if len(time) > 0 {
		// 延时任务
		taskInfo, err := client.Enqueue(t, asynq.ProcessIn(time[0]))
		if err != nil {
			fmt.Println("推送消息入队失败")
			return err
		}
		fmt.Println("推送消息入队成功,入队消息的唯一ID为：", taskInfo.ID)
		return nil
	} else {
		// 非延时任务   将消息推送入队
		taskInfo, err := client.Enqueue(t)
		if err != nil {
			fmt.Println("推送消息入队失败")
			return err
		}
		// 程序一启动，会将消息马上入队，不管消息是否延时
		fmt.Println("推送消息入队成功,入队消息的唯一ID为：", taskInfo.ID)
		return nil
	}
}

-----------------------------------------------------------------------------------------------------------------------------

运行结果：

程序一旦启动，即刻的结果：

启动一分钟的结果：

启动两分钟的结果：

 

正常情况下，延时消息只会执行一次。

 ----------------------------------------------------------------------------------------------------------------------------

 

 为什么会出现延时消息执行两次的情况？

这是因为在第一次启动程序后，我们立刻终止了程序，此时任务被发送到队列，但任务处理器还没来得及处理任务，我们就将程序断开。上文也说了，asynq是基于redis存储的，任务被发送到队列，但没有被处理，任务会挤压在redis。当我们第二次启动程序时，队列再次收到新来的任务后，会将任务转发给任务处理器，任务处理器收到请求，处理任务，任务包含新来的任务和第一次挤压在队列中的任务，所以任务会执行两次。

此处也反映出，并不是任务处理器一直监听队列是否有消息，而是消息队列收到消息会通知任务处理器处理。否则的化，一旦第二次启动程序，挤压的任务会立刻执行，而不是等到新任务到底队列才去执行。

----------------------------------------------------------------------------------------------------------------------------

其他：

参考链接：Asynq简单、可靠、高效的分布式任务队列 - 掘金 (juejin.cn)

谢谢~