Planificateur de tâches de microservice écrit en langage Go

Planificateur de tâches microservice écrit en langage Go

Introduction :
Avec la popularité de l'architecture microservice, le planificateur de tâches est devenu un composant essentiel dans divers systèmes. Grâce au planificateur de tâches, nous pouvons implémenter des fonctions telles que l'exécution planifiée des tâches, le traitement des dépendances des tâches et la surveillance des résultats de l'exécution des tâches. Cet article présentera la méthode d'implémentation du planificateur de tâches de microservice écrit en langage Go et l'illustrera à travers des exemples de code.

1. Conception du modèle de planification des tâches

1. Modèle de tâche
   Le cœur du planificateur de tâches est la planification des tâches, le modèle de tâche doit donc être défini en premier. Une tâche peut contenir les attributs suivants :
2. ID : L'identifiant unique de la tâche, utilisé pour identifier la tâche de manière unique.
3. Nom : Le nom de la tâche, utilisé pour décrire la tâche.
4. Cron : La période de planification de la tâche, qui peut être une heure, un intervalle ou une expression fixe.
5. Dépendances : dépendances de tâches, indiquant les tâches précédentes de la tâche.
6. Handler : fonction de traitement des tâches, utilisée pour exécuter une logique de tâche spécifique.

Vous pouvez définir le modèle de tâche via le code suivant :

type Task struct {

ID           string
Name         string
Cron         string
Dependencies []string
Handler      func() error

}

2. Modèle de planificateur de tâches
   Le planificateur de tâches doit avoir les fonctions d'ajout de tâches, de suppression de tâches, d'exécution de tâches, de tâche. traitement des dépendances, etc. Le modèle du planificateur de tâches peut être défini via le code suivant :

type Scheduler struct {

m sync.Mutex
tasks map[string]*Task
dependencies map[string][]string

}

3. Implémentation de la méthode du planificateur de tâches
   Ensuite, nous devons implémenter la méthode du planificateur de tâches. Vous pouvez ajouter des tâches, supprimer des tâches, exécuter des tâches, gérer les dépendances de tâches et d'autres fonctions au planificateur de tâches via le code suivant :

func (s Scheduler) AddTask(task Task) {

s.m.Lock()
defer s.m.Unlock()

s.tasks[task.ID] = task
// 处理任务依赖关系
for _, dependency := range task.Dependencies {
    s.dependencies[dependency] = append(s.dependencies[dependency], task.ID)
}

}

func ( s *Scheduler ) RemoveTask(taskID string) {

s.m.Lock()
defer s.m.Unlock()

task, ok := s.tasks[taskID]
if ok {
    delete(s.tasks, taskID)
    // 清理任务依赖关系
    for _, dependent := range s.dependencies[taskID] {
        dependentTask, ok := s.tasks[dependent]
        if ok {
            dependentTask.Dependencies = remove(dependentTask.Dependencies, taskID)
        }
    }
    delete(s.dependencies, taskID)
}

}

func (s *Scheduler) RunTask(taskID string) {

s.m.Lock()
defer s.m.Unlock()

task, ok := s.tasks[taskID]
if ok {
    err := task.Handler()
    if err != nil {
        fmt.Printf("Task %s failed to execute: %s

", taskID, err.Error())

    }
}

}

func (s *Scheduler) handleDependencies(taskID string) {

dependentTasks, ok := s.dependencies[taskID]
if ok {
    for _, dependent := range dependentTasks {
        s.RunTask(dependent)
    }
}

}

func (s *Scheduler) RunAllTasks() {

s.m.Lock()
defer s.m.Unlock()

for _, task := range s.tasks {
    s.RunTask(task.ID)
}

}

Analyse du code : La méthode

• AddTask est utilisée pour ajouter des tâches au planificateur de tâches et traiter les dépendances des tâches.
• La méthode RemoveTask est utilisée pour supprimer des tâches du planificateur de tâches et nettoyer les dépendances des tâches.
• La méthode RunTask est utilisée pour exécuter des tâches et imprimer des informations d'erreur lorsque l'exécution des tâches échoue. .Dépendances, c'est-à-dire qu'elles exécutent toutes les tâches qui dépendent de la tâche spécifiée. La méthode
• RunAllTasks est utilisée pour exécuter toutes les tâches du planificateur
2. Ce qui suit est un exemple simple pour montrer comment l'utiliser. cette tâche de microservice.

func main() {

scheduler := &Scheduler{
    tasks:        make(map[string]*Task),
    dependencies: make(map[string][]string),
}

// 初始化任务
task1 := &Task{
    ID:   "1",
    Name: "Task 1",
    Cron: "* * * * *", // 每分钟执行一次
    Handler: func() error {
        fmt.Println("Task 1 Executed")
        return nil
    },
}
task2 := &Task{
    ID:           "2",
    Name:         "Task 2",
    Cron:         "* * * * *", // 每分钟执行一次
    Dependencies: []string{"1"},
    Handler: func() error {
        fmt.Println("Task 2 Executed")
        return nil
    },
}

// 添加任务到任务调度器中
scheduler.AddTask(task1)
scheduler.AddTask(task2)

// 执行任务
scheduler.RunAllTasks()

// 删除任务
scheduler.RemoveTask("2")

// 再次执行任务
scheduler.RunAllTasks()

}

Analyse du code :

Tout d'abord, nous créons une instance du planificateur de tâches et initialisons le planificateur de tâches

Ensuite, nous créons deux tâches et les définissons. Le cycle de planification, les dépendances et les fonctions de traitement de la tâche.
• Ensuite, nous ajoutons la tâche au planificateur de tâches
• Ensuite, nous exécutons toutes les tâches dans le planificateur de tâches
• Enfin, nous supprimons une tâche et recommençons. .Exécutez toutes les tâches dans le planificateur de tâches.
• Résumé :
Cet article présente la méthode d'implémentation du planificateur de tâches du microservice écrit en langage Go et l'illustre à travers les fonctions du planificateur de tâches telles que l'exécution planifiée, le traitement des dépendances de tâches et. la surveillance des résultats de l'exécution des tâches fournit un puissant support de planification des tâches pour l'architecture des microservices du système

.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!