Asynq 實現 Go 後臺作業非同步定時任務處理

hibiken發表於2020-01-26
Go非同步

需要在Go應用程式中非同步處理任務？ Asynq，簡單高效的任務佇列實現。
最近發現了一個很好的Go簡單高效的非同步任務處理庫：Asyqn, 開發自谷歌員工。

安裝

要安裝asynq庫和asynqmon命令列工具，請執行以下命令：

go get -u github.com/hibiken/asynq
go get -u github.com/hibiken/asynq/tools/asynqmon

入門

在本asynq教程中，我們將建立兩個程式。

producer.go 將建立並定時要由consumer非同步處理的任務。

consumer.go 將處理producer建立的任務。

假定在上執行Redis伺服器localhost:6379。在開始之前，請確保已安裝並執行Redis。

我們需要做的第一件事是建立兩個主檔案:

mkdir producer consumer
touch producer/producer.go consumer/consumer.go

匯入asynq兩個檔案：

import "github.com/hibiken/asynq"

Asynq使用Redis作為訊息代理。使用一種RedisConnOpt型別來指定如何連線到Redis。我們這裡將使用RedisClientOpt：

// both in producer.go and consumer.go
var redis = &asynq.RedisClientOpt{
    Addr: "localhost:6379",
    // Omit if no password is required
    Password: "mypassword",
    // Use a dedicated db number for asynq.
    // By default, Redis offers 16 databases (0..15)
    DB: 0,
}

在producer.go，我們將建立一個Client例項來建立和定時任務。
在asynq，要執行的工作單元被封裝在稱為的結構中Task。其中有兩個欄位：Type和Payload。

// Task represents a task to be performed.
type Task struct {
    // Type indicates the type of task to be performed.
    Type string

    // Payload holds data needed to perform the task.
    Payload Payload
}

要建立任務，請使用NewTask函式，併為任務傳遞型別和有效負載。

可以通過Client.Schedule傳入任務和需要處理的時間來計劃任務。

// producer.go
func main() {
    client := asynq.NewClient(redis)

    // Create a task with typename and payload.
    t1 := asynq.NewTask(
        "send_welcome_email",
        map[string]interface{}{"user_id": 42})

    t2 := asynq.NewTask(
        "send_reminder_email",
        map[string]interface{}{"user_id": 42})

    // Process the task immediately.
    err := client.Schedule(t1, time.Now())
    if err != nil {
        log.Fatal(err)
    }

    // Process the task 24 hours later.
    err = client.Schedule(t2, time.Now().Add(24 * time.Hour))
    if err != nil {
        log.Fatal(err)
    }
}

在consumer.go，建立一個Background例來處理任務。

NewBackground函式需要RedisConnOpt和Config。

您可以檢視有關文件，Config以檢視可用的選項。

在此示例中，我們僅指定併發。

// consumer.go
func main() {
    bg := asynq.NewBackground(redis, &asynq.Config{
        Concurrency: 10,
    })

    bg.Run(handler)
}

引數t(*asynq.Background).Run是asynq.Handler具有一種方法的介面ProcessTask。

// ProcessTask should return nil if the processing of a task
// is successful.
//
// If ProcessTask return a non-nil error or panics, the task
// will be retried.
type Handler interface {
    ProcessTask(*Task) error
}

實現處理程式的最簡單方法是定義一個具有相同type的函式，並asynq.HandlerFunc在將其傳遞給時使用介面卡型別Run。

func handler(t *asynq.Task) error {
    switch t.Type {
    case "send_welcome_email":
        id, err := t.Payload.GetInt("user_id")
        if err != nil {
            return err
        }
        fmt.Printf("Send Welcome Email to User %d\n", id)

    case "send_reminder_email":
        id, err := t.Payload.GetInt("user_id")
        if err != nil {
            return err
        }
        fmt.Printf("Send Reminder Email to User %d\n", id)

    default:
        return fmt.Errorf("unexpected task type: %s", t.Type)
    }
    return nil
}

func main() {
    bg := asynq.NewBackground(redis, &asynq.Config{
        Concurrency: 10,
    })

    // Use asynq.HandlerFunc adapter for a handler function
    bg.Run(asynq.HandlerFunc(handler))
}

我們可以繼續向該處理函式新增案例，但是在實際應用中，在單獨的函式中為每種案例定義邏輯很方便。為了重構我們的程式碼，讓我們建立一個簡單的排程程式，將任務型別對映到其處理程式：

// consumer.go

// Dispatcher is used to dispatch tasks to registered handlers.
type Dispatcher struct {
    mapping map[string]asynq.HandlerFunc
}

// HandleFunc registers a task handler
func (d *Dispatcher) HandleFunc(taskType string, fn asynq.HandlerFunc) {
    d.mapping[taskType] = fn
}

// ProcessTask processes a task.
//
// NOTE: Dispatcher satisfies asynq.Handler interface.
func (d *Dispatcher) ProcessTask(task *asynq.Task) error {
    fn, ok := d.mapping[task.Type]
    if !ok {
        return fmt.Errorf("no handler registered for %q", task.Type)
    }
    return fn(task)
}

func main() {
    d := &Dispatcher{mapping: make(map[string]asynq.HandlerFunc)}
    d.HandleFunc("send_welcome_email", sendWelcomeEmail)
    d.HandleFunc("send_reminder_email", sendReminderEmail)

    bg := asynq.NewBackground(redis, &asynq.Config{
        Concurrency: 10,
    })
    bg.Run(d)
}

func sendWelcomeEmail(t *asynq.Task) error {
    id, err := t.Payload.GetInt("user_id")
    if err != nil {
        return err
    }
    fmt.Printf("Send Welcome Email to User %d\n", id)
    return nil
}

func sendReminderEmail(t *asynq.Task) error {
    id, err := t.Payload.GetInt("user_id")
    if err != nil {
        return err
    }
    fmt.Printf("Send Welcome Email to User %d\n", id)
    return nil
}

現在我們既有任務生產者又有消費者，我們可以執行這兩個程式。

go run producer.go

這將建立兩項任務：一項應立即處理，另一項將在24小時後處理。

讓我們使用asynqmon工具檢查任務。

asynqmon stats

你應該能看到，有一個任務Enqueued狀態，另一個在Scheduled狀態。

注意：如需瞭解每種狀態的含義，請參閱Wiki頁面上Life of Task。

讓我們執行asynqmon與watch命令，以便我們能夠連續執行的命令看到的變化。

watch -n 3 asynqmon stats # Runs `asynqmon stats` every 3 seconds

最後，讓我們啟動consumer程式來處理定時的任務。

go run consumer.go

注意：在您傳送訊號終止程式之前，此操作不會退出。有關如何安全終止後臺處理的最佳實踐，請參見Signal Wiki頁面。

您應該能夠看到在終端上列印的文字，表明該任務已成功處理。

這是一次asynq基礎的快速教程。要了解有關其所有功能（如優先順序佇列和自定義重試）的更多資訊，請參見的Wiki頁面。

命令列工具

Asynq附帶了一個命令列工具來檢查佇列和任務的狀態。

要安裝，請執行以下命令：

go get github.com/hibiken/asynq/tools/asynqmon

完成！

例圖：asynqmon_stats.gif

詳情請參考：Asyqn-https://github.com/hibiken/asynq

本作品採用《CC 協議》，轉載必須註明作者和本文連結

相關文章