asynq | go-zero学习 第五章 集成asynq

最新推荐文章于 2024-05-11 17:31:53 发布
最新推荐文章于 2024-05-11 17:31:53 发布
阅读量1.3k 收藏 4
点赞数 1
分类专栏： go-zero 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_XiMu/article/details/131817212
版权

asynq | go-zero学习 第五章 集成asynq

1 前提

asynq是基于redis实现的，且需要高版本的redis，本文使用的是Redis-x64-5.0.14.1。

redis下载地址：

  1. linux/mac系统：https://redis.io/download
  2. windows系统：https://github.com/tporadowski/redis/releases

2 源代码

2.1 官方介绍

  1. Asynq是Go语言中简单、可靠、高效的分布式任务队列。
  2. Asynq 是一个 Go 库，用于对任务进行排队并与工作线程异步处理它们。它由Redis支持，旨在可扩展且易于入门。
  3. Asynq支持高可用性和水平扩展。

Asynq 工作原理的高级概述：

  • 客户端将任务放入队列
  • 服务器从队列中取出任务并为每个任务启动一个工作协程
  • 任务由多个worker同时处理

Asynq的特性：

  1. 保证至少执行一次任务
  2. 支持任务调度
  3. 失败任务的重试
  4. 在工作进程崩溃时自动恢复任务
  5. 权重优先级队列
  6. 严格的优先级队列
  7. 由于 Redis 中的写入速度很快，因此添加任务的延迟较低
  8. 使用唯一选项对任务进行去重
  9. 允许为每个任务设置超时和截止时间
  10. 允许聚合任务组来批处理多个连续操作
  11. 灵活的处理程序接口，支持中间件
  12. 能够暂停队列以停止正在处理队列中的任务
  13. 定时任务
  14. 支持Redis Cluster进行自动分片和高可用性
  15. 支持Redis Sentinels实现高可用性
  16. 与Prometheus集成，以收集和可视化队列指标
  17. Web界面，用于检查和远程控制队列和任务（有Web页面）
  18. CLI命令行界面，用于检查和远程控制队列和任务（有CLI页面）

※2.2 官方Wiki文档（强烈推荐阅读）

在github的asynq代码仓库里，可以看到Wiki，这里就是asynq的官方文档，里面有更详细的使用demo。

Wiki链接地址
在这里插入图片描述

2.3 官方示例

本次示例代码

源代码README.md中的代码示例

  1. /asynq/official/task/task.go
package tasks

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

// A list of task types.
const (
	//TypeEmailDelivery ：任务类型为邮件
	TypeEmailDelivery = "email:deliver"
	//TypeImageResize ：任务类型为邮件
	TypeImageResize = "image:resize"
)

// EmailDeliveryPayload 队列里的任务消息体
type EmailDeliveryPayload struct {
	UserID     int
	TemplateID string
}

// ImageResizePayload 队列里的任务消息体
type ImageResizePayload struct {
	SourceURL string
}

//----------------------------------------------
// Write a function NewXXXTask to create a task.
// A task consists of a type and a payload.
//----------------------------------------------

func NewEmailDeliveryTask(userID int, tmplID string) (*asynq.Task, error) {
	payload, err := json.Marshal(EmailDeliveryPayload{UserID: userID, TemplateID: tmplID})
	if err != nil {
		return nil, err
	}
	return asynq.NewTask(TypeEmailDelivery, payload), nil
}

func NewImageResizeTask(src string) (*asynq.Task, error) {
	payload, err := json.Marshal(ImageResizePayload{SourceURL: src})
	if err != nil {
		return nil, err
	}
	// task options can be passed to NewTask, which can be overridden at enqueue time.
	return asynq.NewTask(TypeImageResize, payload, asynq.MaxRetry(5), asynq.Timeout(20*time.Minute)), nil
}

//---------------------------------------------------------------
// Write a function HandleXXXTask to handle the input task.（编写一个函数 HandleXXXTask 来处理输入的任务）
// Note that it satisfies the asynq.HandlerFunc interface.（请注意它满足 asynq.HandlerFunc 接口。）
//
// Handler doesn't need to be a function. You can define a type
// that satisfies asynq.Handler interface. See examples below.（处理程序不一定需要是一个函数。你可以定义一个满足 asynq.Handler 接口的类型。请参考下面的示例。）
//---------------------------------------------------------------

func HandleEmailDeliveryTask(ctx context.Context, t *asynq.Task) error {
	var p EmailDeliveryPayload
	if err := json.Unmarshal(t.Payload(), &p); err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	log.Printf("Sending Email to User: user_id=%d, template_id=%s", p.UserID, p.TemplateID)
	// Email delivery code ...
	return nil
}

// ImageProcessor implements asynq.Handler interface.
type ImageProcessor struct {
	// ... fields for struct
}

func (processor *ImageProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error {
	var p ImageResizePayload
	if err := json.Unmarshal(t.Payload(), &p); err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	log.Printf("Resizing image: src=%s", p.SourceURL)
	// Image resizing code ...
	return nil
}

func NewImageProcessor() *ImageProcessor {
	return &ImageProcessor{}
}
  1. /asynq/official/client/client.go
package main

import (
	tasks "go-zero-micro/asynq/official/task"
	"log"
	"time"

	"github.com/hibiken/asynq"
)

const redisAddr = "127.0.0.1:6379"

func main() {
	client := asynq.NewClient(asynq.RedisClientOpt{Addr: redisAddr})
	defer client.Close()

	// ------------------------------------------------------
	// Example 1: Enqueue task to be processed immediately.
	//            Use (*Client).Enqueue method.
	// ------------------------------------------------------

	task, err := tasks.NewEmailDeliveryTask(42, "some:template:id")
	if err != nil {
		log.Fatalf("could not create task: %v", err)
	}
	info, err := client.Enqueue(task)
	if err != nil {
		log.Fatalf("could not enqueue task: %v", err)
	}
	log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)

	// ------------------------------------------------------------
	// Example 2: Schedule task to be processed in the future.
	//            Use ProcessIn or ProcessAt option.
	// ------------------------------------------------------------

	info, err = client.Enqueue(task, asynq.ProcessIn(24*time.Hour))
	if err != nil {
		log.Fatalf("could not schedule task: %v", err)
	}
	log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)

	// ----------------------------------------------------------------------------
	// Example 3: Set other options to tune task processing behavior.
	//            Options include MaxRetry, Queue, Timeout, Deadline, Unique etc.
	// ----------------------------------------------------------------------------

	task, err = tasks.NewImageResizeTask("https://example.com/myassets/image.jpg")
	if err != nil {
		log.Fatalf("could not create task: %v", err)
	}
	info, err = client.Enqueue(task, asynq.MaxRetry(10), asynq.Timeout(3*time.Minute))
	if err != nil {
		log.Fatalf("could not enqueue task: %v", err)
	}
	log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
}
  1. /asynq/official/server/server.go
package main

import (
	tasks "go-zero-micro/asynq/official/task"
	"log"

	"github.com/hibiken/asynq"
)

const redisAddr = "127.0.0.1:6379"

func main() {
	srv := asynq.NewServer(
		asynq.RedisClientOpt{Addr: redisAddr},
		asynq.Config{
			// Specify how many concurrent workers to use
			Concurrency: 10,
			// Optionally specify multiple queues with different priority.
			Queues: map[string]int{
				"critical": 6,
				"default":  3,
				"low":      1,
			},
			// See the godoc for other configuration options
		},
	)

	// mux maps a type to a handler
	mux := asynq.NewServeMux()
	mux.HandleFunc(tasks.TypeEmailDelivery, tasks.HandleEmailDeliveryTask)
	mux.Handle(tasks.TypeImageResize, tasks.NewImageProcessor())
	// ...register other handlers...

	if err := srv.Run(mux); err != nil {
		log.Fatalf("could not run server: %v", err)
	}
}

3 asynq介绍

3.1 简单介绍

asynq 是一个基于 Go 的开源异步任务处理框架，它提供了一种简单的方式来处理异步任务，如任务队列、定时任务等。asynq 可以轻松地与现有的应用程序集成，并且非常易于使用。

3.2 常用API

  1. NewServer(opts ...Option) *Server：创建一个新的异步任务处理器。
  2. Server.Enqueue(task *Task) error：将任务添加到任务队列中。
  3. Server.EnqueueAt(task *Task, t time.Time) error：将任务添加到定时任务队列中，指定任务的执行时间。
  4. Server.EnqueueIn(task *Task, d time.Duration) error：将任务添加到延迟任务队列中，指定任务的延迟时间。
  5. Server.ProcessTask(fn func(ctx context.Context, task *Task) error) error：自定义任务处理器，可以编写自己的任务处理逻辑。
  6. Server.Start() error：启动异步任务处理器。
  7. Server.Shutdown(ctx context.Context) error：停止异步任务处理器。
  8. NewTask(typ string, payload Payload) *Task：创建一个新的任务。
  9. Task.Meta()：获取任务的元数据。
  10. Task.Payload() Payload：获取任务的负载数据。
  11. Task.Type() string：获取任务的类型。
  12. Task.ID() string：获取任务的唯一标识符。

此外，asynq 还提供了许多其他的 API，如任务重试、任务优先级、任务过期等。具体的 API 可以参考 asynq 的文档。

3.3 应用场景

  1. 异步任务处理：asynq 可以将异步任务添加到任务队列中，并在后台异步处理这些任务。这对于需要进行耗时操作的应用程序非常有用，如发送电子邮件、生成 PDF 文件、处理图像等。
  2. 定时任务处理：asynq 可以在指定的时间执行任务，这对于需要在特定时间执行操作的应用程序非常有用，如发送定期报告、执行备份操作等。
  3. 任务重试：asynq 可以自动重试失败的任务，这对于需要处理不稳定网络或外部系统的应用程序非常有用。
  4. 任务优先级管理：asynq 可以根据任务的优先级来处理任务，这对于需要处理紧急任务或高优先级任务的应用程序非常有用。
  5. 延迟任务处理：asynq 可以在指定的时间后执行任务，这对于需要处理延迟操作的应用程序非常有用，如处理付款、取消订单等。

※4 asynq具体讲解及示例

  1. 官方Wiki文档
  2. 源代码

通过官方Wiki文档可以选择合适的解决方案。（官方文档和源代码为主要参考）

4.1 asynq入门

入门：有异步任务处理的代码示例。

4.2 server端自定义结构体类型实现处理任务

server端自定义结构体类型实现处理任务：有代码示例。

4.3 server端使用中间件

server端使用中间件：有代码示例。

4.4 任务的生命周期

任务的生命周期)：纯讲解。

4.4 信号

信号：纯讲解，注意目前Windows不支持TSTP信号。

4.5 队列优先级

队列优先级：有代码示例。

4.6 任务重试

任务重试：有代码示例。

4.7 任务超时和取消

任务超时和取消：有代码示例。

4.8 周期性任务

周期性任务：有代码示例。

4.9 周期性任务（动态）

周期性任务（动态）：有代码示例。

4.10 速率限制

速率限制：有代码示例。

4.11 任务唯一性

任务唯一性：有代码示例。

4.12 任务保留和结果

任务保留和结果：有代码示例。

4.13 任务聚合

任务聚合：有代码示例。

4.14 Redis集群

Redis集群：有代码示例。

4.15 自动故障转移

自动故障转移：有代码示例。

4.16 监控和警报

监控和警报：纯讲解。

5 亲自实践

5.1 参考文档

  1. 官方文档
  2. 源代码

通过官方文档可以选择合适的解决方案。（官方文档和源代码为主要参考）

这里仅展示 异步任务处理、定时任务处理、任务重试处理、任务优先级管理、延迟任务处理 这五个类型以及asynq的Web UI工具asynqmon的使用。

5.2 异步任务处理

本次示例代码

以异步发送邮件为例，这个示例其实与官方示例是大同小异，这里是拆分成单个示例了。

5.2.1 具体代码

  1. /asynq/others_demo/async_task_demo/async_task_task/task.go
package async_task_task

import (
	"encoding/json"
	"fmt"
	"github.com/hibiken/asynq"
	"golang.org/x/net/context"
)

// 创建一个新任务类型
const AsyncEmailTask = "async_email_task"

// AsyncEmailPayload 定义发送邮件的负载数据结构
type AsyncEmailPayload struct {
	To      string `json:"to"`
	Subject string `json:"subject"`
	Body    string `json:"body"`
}

// NewAsyncEmailTask 创建异步电子邮件任务的函数
func NewAsyncEmailTask(asyncEmail AsyncEmailPayload) (*asynq.Task, error) {
	payload, err := json.Marshal(asyncEmail)
	if err != nil {
		return nil, err
	}
	task := asynq.NewTask(AsyncEmailTask, payload)
	return task, err
}

// HandleAsyncEmailTask 处理异步电子邮件任务的函数
func HandleAsyncEmailTask(ctx context.Context, task *asynq.Task) error {
	payload := AsyncEmailPayload{}
	if err := json.Unmarshal(task.Payload(), &payload); err != nil {
		return err
	}
	// TODO: 模拟发送邮件
	fmt.Printf("\nAsync Server：Start handle AsyncTask!")
	fmt.Printf("Sending email to %s, subject: %s, body: %s\n", payload.To, payload.Subject, payload.Body)
	fmt.Println("Async Server：End handle AsyncTask!")
	return nil
}
  1. /asynq/others_demo/async_task_demo/async_task_client/client.go
package main

import (
	"fmt"
	"github.com/hibiken/asynq"
	"go-zero-micro/asynq/others_demo/async_task_demo/async_task_task"
	"go-zero-micro/common/utils"
	"log"
	"time"
)

const redisAddr = "127.0.0.1:6379"

func main() {
	client := asynq.NewClient(asynq.RedisClientOpt{Addr: redisAddr})
	defer client.Close()

	//emailBody := fmt.Sprintf("异步任务邮件已发送，发送时间：%s", time.Now().Format(utils.DateTimeFormat))
	//asyncEmail := async_task_task.AsyncEmailPayload{
	//	To:      "user@example.com",
	//	Subject: "异步任务邮件",
	//	Body:    emailBody,
	//}
	//task, err := async_task_task.NewAsyncEmailTask(asyncEmail)
	//if err != nil {
	//	log.Fatalf("could not create task: %v", err)
	//}
	//info, err := client.Enqueue(task)
	//if err != nil {
	//	log.Fatalf("could not enqueue task: %v", err)
	//}
	//log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)

	for i := 0; i < 5; i++ {
		emailBody := fmt.Sprintf("异步任务邮件已发送，发送时间：%s", time.Now().Format(utils.DateTimeFormat))
		asyncEmail := async_task_task.AsyncEmailPayload{
			To:      "user@example.com",
			Subject: "异步任务邮件",
			Body:    emailBody,
		}
		task, err := async_task_task.NewAsyncEmailTask(asyncEmail)
		time.Sleep(time.Second)
		if err != nil {
			log.Fatalf("could not create task: %v", err)
		}
		//设定服务端立即处理任务
		info, err := client.Enqueue(task)
		if err != nil {
			log.Fatalf("could not enqueue task: %v", err)
		}
		log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
	}
}
  1. /asynq/others_demo/async_task_demo/async_task_task_server/server.go
package main

import (
	"go-zero-micro/asynq/others_demo/async_task_demo/async_task_task"
	"log"

	"github.com/hibiken/asynq"
)

const redisAddr = "127.0.0.1:6379"

func main() {
	srv := asynq.NewServer(
		asynq.RedisClientOpt{Addr: redisAddr},
		asynq.Config{
			// Specify how many concurrent workers to use
			Concurrency: 10,
			// Optionally specify multiple queues with different priority.
			Queues: map[string]int{
				"critical": 6,
				"default":  3,
				"low":      1,
			},
			// See the godoc for other configuration options
		},
	)

	// mux maps a type to a handler
	mux := asynq.NewServeMux()
	mux.HandleFunc(async_task_task.AsyncEmailTask, async_task_task.HandleAsyncEmailTask)
	// ...register other handlers...

	if err := srv.Run(mux); err != nil {
		log.Fatalf("could not run server: %v", err)
	}
}

启动演示：
先启动服务端，再启动客户端。

※5.2.2 自定义server端处理任务方法

asynq的服务端除了直接调用处理任务的方法外，也可以通过声明结构体来实现asynq.Handler里的ProcessTask(context.Context, *Task) error接口来处理任务，这样会更加灵活，但是要注意直接调用和通过实现接口只能二选一。

参考：server端自定义结构体类型实现处理任务：有代码示例。
具体代码（核心代码）：

  1. /asynq/others_demo/async_task_demo/async_task_task/task.go
// AsyncEmailProcessor implements asynq.Handler interface.
type AsyncEmailProcessor struct {
	// ... fields for struct
}

func NewAsyncEmailProcessor() *AsyncEmailProcessor {
	return &AsyncEmailProcessor{}
}

func (processor *AsyncEmailProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error {
	var payload AsyncEmailPayload
	if err := json.Unmarshal(t.Payload(), &payload); err != nil {
		//return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
		return err
	}
	// TODO: 模拟发送邮件
	fmt.Printf("\nAsync Server：ProcessTask：Start handle AsyncTask!\n")
	fmt.Printf("Sending email to %s, subject: %s, body: %s\n", payload.To, payload.Subject, payload.Body)
	fmt.Println("Async Server：ProcessTask：End handle AsyncTask!")
	return nil
}
  1. /asynq/others_demo/async_task_demo/async_task_task_server/server.go
	//mux.HandleFunc(async_task_task.AsyncEmailTask, async_task_task.HandleAsyncEmailTask)
	mux.Handle(async_task_task.AsyncEmailTask, async_task_task.NewAsyncEmailProcessor())

5.3 定时任务处理

5.3.1 使用定时器(Ticker)实现

本次示例代码

定时任务示例的代码与异步任务比较类似，所以复用了异步任务的task.go和server.go的代码，这里只展示定时任务client.go的代码。

package main

import (
	"fmt"
	"github.com/hibiken/asynq"
	"go-zero-micro/asynq/others_demo/async_task_demo/async_task_task"
	"go-zero-micro/common/utils"
	"log"
	"time"
)

const redisAddr = "127.0.0.1:6379"

func main() {
	client := asynq.NewClient(asynq.RedisClientOpt{Addr: redisAddr})
	defer client.Close()

	StartUpScheduledTask(client, 10*time.Second) // 每隔 10 秒执行一次发送数据任务)
}

func StartUpScheduledTask(client *asynq.Client, interval time.Duration) {
	ticker := time.NewTicker(interval)
	defer ticker.Stop()
	for range ticker.C {
		emailBody := fmt.Sprintf("定时任务邮件已发送，发送时间：%s", time.Now().Format(utils.DateTimeFormat))
		scheduledEmail := async_task_task.AsyncEmailPayload{
			To:      "user@example.com",
			Subject: "定时任务邮件",
			Body:    emailBody,
		}
		task, err := async_task_task.NewAsyncEmailTask(scheduledEmail)
		//info, err := client.Enqueue(task)
		
		//※ asynq.ProcessAt(time.Now().Add(interval))是让服务端延迟指定的时间执行
		info, err := client.Enqueue(task, asynq.ProcessAt(time.Now().Add(interval)))

		if err != nil {
			log.Fatalf("could not enqueue task: %v", err)
		}
		log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
	}
}

启动步骤也是先服务端，后客户端。

注意：

  • 客户端定时添加任务到队列中时，还加入参数asynq.ProcessAt(time.Now().Add(interval))是让服务端延迟指定的时间执行。
  • 可以通过对比服务端处理时间和客户端添加时间发现服务端在处理时确实延迟了指定时间间隔。

※5.3.2 使用cron实现

本次示例代码

使用Golang的周期性定时器(Ticker)实现定时器不够灵活，比如设定具体的执行时间等，这时可以使用cron来实现。

参考：周期性任务：有代码示例。
client.go代码：

package main

import (
	"fmt"
	"github.com/hibiken/asynq"
	"go-zero-micro/asynq/others_demo/async_task_demo/async_task_task"
	"log"
	"time"
)

const redisAddr = "127.0.0.1:6379"

func main() {
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		panic(err)
	}
	scheduler := asynq.NewScheduler(
		&asynq.RedisClientOpt{
			Addr: redisAddr,
		},
		&asynq.SchedulerOpts{
			Location: loc,
		},
	)

	//emailBody := fmt.Sprintf("定时任务邮件已发送，发送时间：%s", time.Now().Format(utils.DateTimeFormat))
	emailBody := fmt.Sprintf("定时任务邮件已发送！")
	scheduledEmail := async_task_task.AsyncEmailPayload{
		To:      "user@example.com",
		Subject: "定时任务邮件",
		Body:    emailBody,
	}
	task, err := async_task_task.NewAsyncEmailTask(scheduledEmail)

	if err != nil {
		log.Fatal(err)
	}

	//entryID1, err := scheduler.Register("* * * * *", task) //每分钟执行一次任务
	//entryID1, err := scheduler.Register("*/1 * * * *", task) //每分钟执行一次任务
	entryID1, err := scheduler.Register("*/2 * * * *", task) //每2分钟执行一次任务
	//entryID1, err := scheduler.Register("@every 10s", task) //每隔10秒执行1次
	//entryID1, err := scheduler.Register("@every 1m", task)  //每隔1分钟执行1次
	//entryID1, err := scheduler.Register("@every 1h", task)  //每隔1小时执行1次
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("registered an entry: %q\n", entryID1)
	// 运行
	if err := scheduler.Run(); err != nil {
		log.Fatal(err)
	}
}

5.4 任务重试处理

本次示例代码

任务重试处理有两个地方可以配置，分别是在创建任务时，任务入队时。

参考：任务重试：有代码示例。

5.4.1 创建任务时设置

创建任务时设置重试次数、超时时间。

package main

import (
	"encoding/json"
	"fmt"
	"github.com/hibiken/asynq"
	"go-zero-micro/asynq/others_demo/async_task_demo/async_task_task"
	"go-zero-micro/common/utils"
	"log"
	"time"
)

const redisAddr = "127.0.0.1:6379"

func main() {
	emailBody := fmt.Sprintf("定时任务邮件已发送，发送时间：%s", time.Now().Format(utils.DateTimeFormat))
	retryEmail := async_task_task.AsyncEmailPayload{
		To:      "user@example.com",
		Subject: "定时任务邮件",
		Body:    emailBody,
	}
	task, err := NewRetryEmailTask(retryEmail)
	if err != nil {
		log.Fatal(err)
	}
	client := asynq.NewClient(asynq.RedisClientOpt{Addr: redisAddr})
	info, err := client.Enqueue(task)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
}

// NewRetryEmailTask 创建重试电子邮件任务的函数
func NewRetryEmailTask(asyncEmail async_task_task.AsyncEmailPayload) (*asynq.Task, error) {
	payload, err := json.Marshal(asyncEmail)
	if err != nil {
		return nil, err
	}
	//任务级别：创建任务时设置重试次数、超时时间
	task := asynq.NewTask(async_task_task.AsyncEmailTask, payload, asynq.MaxRetry(5), asynq.Timeout(1*time.Minute))
	return task, err
}

5.4.2 任务入队时设置

任务入队时设置重试次数、超时时间。

package main

import (
	"encoding/json"
	"fmt"
	"github.com/hibiken/asynq"
	"go-zero-micro/asynq/others_demo/async_task_demo/async_task_task"
	"go-zero-micro/common/utils"
	"log"
	"time"
)

const redisAddr = "127.0.0.1:6379"

func main() {
	emailBody := fmt.Sprintf("定时任务邮件已发送，发送时间：%s", time.Now().Format(utils.DateTimeFormat))
	retryEmail := async_task_task.AsyncEmailPayload{
		To:      "user@example.com",
		Subject: "定时任务邮件",
		Body:    emailBody,
	}
	task, err := NewRetryEmailTask(retryEmail)
	if err != nil {
		log.Fatal(err)
	}
	client := asynq.NewClient(asynq.RedisClientOpt{Addr: redisAddr})
	info, err := client.Enqueue(task, asynq.MaxRetry(5), asynq.Timeout(1*time.Minute))
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
}

// NewRetryEmailTask 创建重试电子邮件任务的函数
func NewRetryEmailTask(asyncEmail async_task_task.AsyncEmailPayload) (*asynq.Task, error) {
	payload, err := json.Marshal(asyncEmail)
	if err != nil {
		return nil, err
	}
	//任务级别：创建任务时设置重试次数、超时时间
	task := asynq.NewTask(async_task_task.AsyncEmailTask, payload, asynq.MaxRetry(5), asynq.Timeout(1*time.Minute))
	return task, err
}

5.5 任务优先级管理

参考：队列优先级：有代码示例。

5.6 延迟任务处理

参考：入门。

主要是客户端在将任务入队时使用ProcessIn或ProcessAt选项来安排将来要处理的任务。

ProcessIn：

	info, err = client.Enqueue(task, asynq.ProcessIn(24*time.Hour))

ProcessAt：

package main

import (
	"fmt"
	"github.com/hibiken/asynq"
	"go-zero-micro/asynq/others_demo/async_task_demo/async_task_task"
	"go-zero-micro/common/utils"
	"log"
	"time"
)

const redisAddr = "127.0.0.1:6379"

func main() {
	client := asynq.NewClient(asynq.RedisClientOpt{Addr: redisAddr})
	defer client.Close()

	StartUpScheduledTask(client, 10*time.Second) // 每隔 10 秒执行一次发送数据任务)
}

func StartUpScheduledTask(client *asynq.Client, interval time.Duration) {
	ticker := time.NewTicker(interval)
	defer ticker.Stop()
	for range ticker.C {
		emailBody := fmt.Sprintf("定时任务邮件已发送，发送时间：%s", time.Now().Format(utils.DateTimeFormat))
		scheduledEmail := async_task_task.AsyncEmailPayload{
			To:      "user@example.com",
			Subject: "定时任务邮件",
			Body:    emailBody,
		}
		task, err := async_task_task.NewAsyncEmailTask(scheduledEmail)
		//info, err := client.Enqueue(task)

		//※ asynq.ProcessAt(time.Now().Add(interval))是让服务端延迟指定的时间执行
		info, err := client.Enqueue(task, asynq.ProcessAt(time.Now().Add(interval)))

		if err != nil {
			log.Fatalf("could not enqueue task: %v", err)
		}
		log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
	}
}

5.7 Web UI工具asynqmon

asynqmon源代码：https://github.com/hibiken/asynqmon

6 go-zero中使用asynq

本次代码示例
参考文档：

  1. go-zero-looklook中定时任务
  2. go-zero asynq 定时任务最佳实践

在go-zero使用asynq前，如果对asynq服务端、客户端的代码结构有更清楚的了解，在go-zero集成asynq时会更加轻松，很快能够明白各处的作用。

本次示例是将asynq服务端和asynq客户端放到同一个服务里，按照先服务端后客户端的顺序启动，也可以拆分成两个独立的服务，根据自己的实际需求改造即可。

西木Qi
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
asynq源码阅读
dreambreeze110的博客
12-17 600
这个库实现了任务队列的基本功能，目前star数有7.1k，还不错。个人看法：可以当成一种轻量级的任务队列或者消息队列使用，但是是否在关键业务中使用，慎重。我们可以看到，asynq的server启动了很多goroutine，包括健康检查，任务处理等。我们这里只看普通任务的投递逻辑。我们先从官方提供的Client示例的入口来看一下asynq的任务存储是怎么实现的。将任务的信息存储到hash字典中中，包括任务的消息数据，任务状态，任务的入队时间。判断任务是否已经存在，如果存在，返回0。否则，继续执行下一步。
Asynq：Go的简单，可靠和高效的分布式任务队列-Golang开发
05-26
Asynq概述Asynq是一个Go库，用于对任务进行排队并与工作人员在后台进行处理。 它具有Redis的支持，并且设计为具有较低的进入门槛。 它应该集成在您中。Asynq概述Asynq是一个Go库，用于对任务进行排队并与工作人员在后台进行处理。 它具有Redis的支持，并且设计为具有较低的进入门槛。 它应该轻松地集成到您的Web堆栈中。 有关Asynq的工作原理的高级概述：客户端将任务放入队列中服务器将任务从队列中拉出并为每个任务启动工作程序goroutine每个任务由多个工作程序同时处理任务队列用作一种在多个任务之间分配工作的机制
Go异步任务解决方案 Asynq_如何单独对go asynq servers不下发任务
2401_84265751的博客
04-17 777
/ HandleEmailDeliveryTask 发送email处理逻辑。// EmailDeliveryPayload 异步任务需要传递的数据结构。// NewEmailDeliveryTask 异步任务需要传递的数据。// 有效载荷保存执行任务所需的数据，有效负载值必须是可序列化的.// 一个简单的字符串值，表示要执行的任务的类型.// 每个进程并发执行的worker数量。// 初使货需要传递的数据。// 任务的结果编写器.//逻辑处理start…来创建处理程序，就像使用。// 保存任务的选项.
一文带您了解Go异步任务处理解决方案：Asynq
网络技术联盟站
06-03 2241
在计算机领域，异步任务通常指需要长时间运行的操作，例如网络请求、大量数据的处理或者其他需要耗费较长时间的任务。这些任务通常不会阻塞主线程或阻塞其他任务的执行，因此它们需要以异步的方式进行处理。在Go语言中，异步任务一般使用goroutine和channel来实现。Goroutine是一种轻量级的线程，可以在单个进程中同时运行多个Goroutine。Channel是一种特殊的数据类型，它用于Goroutine之间的通信和同步。通过使用goroutine和channel，我们可以轻松地实现异步任务处理。
go-zero整合asynq实现分布式定时任务
最新发布
宋发元
05-11 357
本教程基于go-zero微服务入门教程，项目工程结构同上一个教程。本教程主要实现go-zero整合asynq实现分布式定时任务。（教程源码分支：4.zero整合asynq定时任务）
Asynq 高性能分布式任务队列实践
张成基
03-14 5189
Asynq 高性能分布式任务队列
asynq：Asynq：Go中简单，可靠，高效的分布式任务队列
02-03
异步 总览 Asynq是一个Go库，用于对任务进行排队并与工作人员异步处理它们。 它由Redis支持，旨在可扩展但易于上手。 有关Asynq工作原理的高级概述： 客户端将任务放入队列 服务器将任务从队列中拉出并为每个任务启动工作程序 任务由多个工作人员同时处理 任务队列用作在多台计算机之间分配工作的机制。 一个系统可以由多个工作服务器和代理组成，让位于高可用性和水平扩展。 稳定性和相容性 重要说明：当前主要版本为零（v0.xx），以适应快速开发和快速迭代，同时获得用户的早期反馈（感谢API反馈！）。 在发布v1.0.0之前，如果不进行主要版本更新，则公共API可能会更改。 现状：该库目前正进行大量开发，API频繁且中断更改。 产品特点 保证一项任务 计划任务 耐用性，因为任务已写入Redis 失败的任务 工作人员崩溃时自动恢复任务 由于Redis中的写入速度很快，因此添加任务的延迟很短 使用对任务进行重复数据删除 允许 以停止处理队列中的任务 以实现自动分片和高可用性 以实现高可用性 用于检查和远程控制队列和任务 检查和远程控制队列和任务 快速开始 首先，请确保您在本地运行Re
go-zero-master
06-16
5. **配置管理**：通过集成如 Nacos 或 Apollo 等配置中心，Go-Zero-Master 实现了动态配置管理，使得服务配置可以在运行时更新，无需重启服务。 6. **熔断与降级**：借鉴 Hystrix 模块的理念，Go-Zero-Master 提供...
Go微服务精讲：Go-Zero全流程实战即时通讯（13章）
03-21
go-zero 是一个集成了各种工程实践的 web 和 rpc 框架。通过弹性设计保障了大并发服务端的稳定性，经受了充分的实战检验。go-zero 包含极简的 AP!定义和生成工具 goct，可以根据定义的 api文件一键生成 Go,i0s, ...
go-zero是一个集成了各种工程实践的web和rpc框架-Golang开发
05-26
go-zero是一个集成了各种工程实践的web和rpc框架。通过弹性设计保障了大并发服务端的稳定性，经受了充分的实战检验。包含极简的API定义和生成工具，可以一键生成Go, iOS, Android, Dart, TypeScript, JavaScript代码...
go-zero（go-zero-1.5.5.tar.gz）
08-28
Go-Zero（go-zero-1.5.5.tar.gz）是一款基于Golang语言的高效Web和RPC框架，它致力于提供一套完整的工程化解决方案，帮助开发者在构建大规模并发服务时确保系统的稳定性和可靠性。这款框架已经经过了大量的实战测试...
asynq:用于异步编程的Python库
05-02
asynq是用于Python中异步编程的库，其重点是批处理对外部服务的请求。 它还提供了与同步代码的无缝互操作性，对异步上下文管理器的支持以及使编写和测试异步代码更加容易的工具。 asynq是由Quora开发的，是Quora体系结构的核心组件。 在查看原始博客文章。 asynq最重要的用例是批处理。 对于许多存储服务（例如，内存缓存，redis），发出一个立即获取多个密钥的请求要快于发出多个每个获取单个密钥的请求的速度。 使用asynq框架，可以轻松编写利用批处理功能的代码，而无需对不使用批处理功能的代码进行根本的代码结构更改。 例如，用于检索Quora答案列表的作者姓名的同步代码可能如下所示： def all_author_names ( aids ): uids = [ author_of_answer ( aid ) for aid in aids ] name
asynq是一个用于在Python中异步编程的库-python
06-18
asynq是一个用于在Python中异步编程的库，关注于对外部服务的批量请求。它还提供与同步代码的无缝互操作，支持异步上下文管理，以及提供让编写和测试异步代码更容易的工具。asynq是在Quora开发的，并且是Quora架构的一个核心组件。 asynq 是一个用于 Python 异步编程的库，专注于批处理对外部服务的请求。 它还提供与同步代码的无缝互操作性、对异步上下文管理器的支持以及使编写和测试异步代码更容易的工具。 asynq 是在 Quora 开发的，是 Quora 架构的核心组件。 在此处查看原始博客文章。 asynq 最重要的用例是批处理。 对于许多存储服务（例如，memcache、redis），发出一次获取多个键的单个请求比发出每个获取单个键的多个请求要快得多。 asynq 框架可以轻松编写利用批处理的代码，而无需从不使用批处理的代码中彻底改变代码结构。 例如，检索 Quora 答案列表的作者姓名的同步代码可能如下所示： def all_author_names(aids): uids = [author_of_answer(aid) for aid in
go-zero（go-zero-1.5.5.zip）
08-28
在实际项目中，使用 `go-zero` 框架可以快速搭建稳定可靠的Web服务和RPC服务，同时得益于Go语言的特性，使得系统在面对高并发场景时具备出色的表现。对于熟悉Go语言的开发者来说，`go-zero` 提供了一个强大的工具箱...
Asynq 实现 Go 异步任务处理
lff的博客
05-15 2820
asynq异步任务的使用
Go异步任务解决方案 Asynq
热门推荐
王中阳的博客
02-06 1万+
Asynq 是一个 Go 库，用于对任务进行排队并与工作人员异步处理它们。
go-zero微服务到k8s部署应有尽有系列（八）消息、延迟、定时队列
吕秀军的博客
02-17 2968
go-zero微服务到k8s部署应有尽有系列（八）消息、延迟、定时队列
asynq队列如何配置队列优先级
phplife的电子商务网上商城专栏
08-02 893
公司上线asynq队列服务已经有两个月了，用得一直很好，比较稳定，目前只用了三台服务器跑任务,任务类型随着业务不断的切到asynq上，队列上的任务类型也越来越多，考虑把一些重要的任务的优先级提高一下，研究一下官方文档，看如何为不同的任务类型配置asynq的任务优先级提示以下是本篇文章正文内容，下面案例可供参考asynq队列队列优先级配置让我们可以安照业务的实际优先级把不同的任务放入不同的队列，解决了队列有优先级要求的场景。.........
【go-zero】go-zero架构逐一突破:go-zero整合 masterminds/squirrel 优雅的实现多
12-08
go-zero是一个开源的Go语言框架，它在构建微服务和高并发应用方面具有突破性的优势。其中一个突出的特点就是它整合了masterminds/squirrel，从而实现了优雅的多数据库支持。 masterminds/squirrel是一个流行的SQL查询构建器，它以非常直观和灵活的方式提供了编写SQL查询的功能。而go-zero在此基础上做了进一步的封装和优化，使得使用者能够更加方便地编写和执行SQL查询。 首先，go-zero提供了一组简洁而强大的API，使得构建SQL查询非常容易。开发者只需要按照一定的约定来创建查询参数和条件，然后使用go-zero提供的API来构建查询语句，即可完成复杂的SQL查询。 其次，go-zero还增加了一些高级功能，进一步提升了多数据库查询的灵活性和性能。例如，它支持数据库连接池管理，可以动态调整数据库连接数以适应并发请求；还支持分表分库功能，可以按照一定的规则将数据分散存储在不同的数据库或表中，从而提高查询效率。 最重要的是，go-zero通过内置的代码生成工具，提供了自动化生成数据库访问代码的能力。开发者只需要定义数据表的结构，然后运行代码生成工具，就能够自动生成包含增删改查等一系列数据库操作的代码。这极大地提高了开发效率，减少了出错的机会。 综上所述，go-zero整合了masterminds/squirrel，通过提供简洁强大的API、高级功能和自动化代码生成工具，实现了优雅的多数据库支持。它在微服务和高并发应用场景下的表现突出，为开发者提供了极大的便利和效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值