Comment développer un système simple de planification de tâches en utilisant MySQL et le langage Go

Comment développer un système de planification de tâches simple à l'aide de MySQL et du langage Go

Le système de planification de tâches est un scénario d'application courant, qui peut nous aider à gérer et à exécuter différents types de tâches. Cet article expliquera comment utiliser les langages MySQL et Go pour développer un système simple de planification de tâches et fournira des exemples de code spécifiques.

1. Créer une table de base de données

Tout d'abord, nous devons créer une table de base de données pour stocker les informations sur les tâches. Dans MySQL, vous pouvez utiliser la commande suivante pour créer une table nommée tâches :

CREATE TABLE tasks (
  id INT AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  schedule_time DATETIME NOT NULL,
  status ENUM('pending', 'running', 'finished', 'failed') NOT NULL DEFAULT 'pending'
);

La table contient les champs suivants :

• id : L'identifiant unique de la tâche, utilisant une clé primaire auto-incrémentée.
• name : Le nom de la tâche.
• schedule_time : L'heure d'exécution prévue de la tâche.
• status : l'état d'exécution de la tâche, y compris en attente (à exécuter), en cours d'exécution (en cours d'exécution), terminé (exécution terminée) et échoué (échec de l'exécution).

2. Connectez-vous à la base de données

En langage Go, vous pouvez utiliser le package database/sql pour vous connecter et faire fonctionner la base de données. Tout d'abord, nous devons importer les packages concernés : database/sql包来连接和操作数据库。首先，我们需要导入相关的包：

import (
  "database/sql"
  _ "github.com/go-sql-driver/mysql"
)

然后，可以使用以下代码连接到MySQL数据库：

db, err := sql.Open("mysql", "用户名:密码@tcp(localhost:3306)/数据库名")
if err != nil {
  log.Fatal(err)
}
defer db.Close()

3. 创建定时任务

接下来，我们将使用Go语言中的time包和goroutine来创建定时任务。首先，我们需要编写一个函数来执行具体的任务逻辑。例如，以下代码定义了一个简单的任务逻辑，即输出任务名称和当前时间：

func taskFunc(name string) {
  fmt.Printf("任务 %s 执行时间：%s
", name, time.Now().Format("2006-01-02 15:04:05"))
}

然后，我们可以使用以下代码来创建一个定时任务，让其在指定的时间执行：

func scheduleTask(db *sql.DB, name string, scheduleTime time.Time) {
  // 将任务插入数据库
  _, err := db.Exec("INSERT INTO tasks (name, schedule_time) VALUES (?, ?)", name, scheduleTime)
  if err != nil {
    log.Fatal(err)
  }

  // 进行定时调度
  duration := time.Until(scheduleTime)
  time.AfterFunc(duration, func() {
    // 更新任务状态为running
    _, err := db.Exec("UPDATE tasks SET status = 'running' WHERE name = ? AND schedule_time = ?", name, scheduleTime)
    if err != nil {
      log.Fatal(err)
    }

    // 执行任务
    taskFunc(name)

    // 更新任务状态为finished
    _, err = db.Exec("UPDATE tasks SET status = 'finished' WHERE name = ? AND schedule_time = ?", name, scheduleTime)
    if err != nil {
      log.Fatal(err)
    }
  })
}

以上代码中，首先向数据库插入任务信息，然后计算当前时间到任务执行时间的时间差，使用time.AfterFunc函数创建一个定时器，在指定的时间后执行任务逻辑。在任务执行前后，我们还更新了任务的状态。

4. 调度任务

现在，我们可以编写一个函数来调度多个任务。例如，以下代码创建了两个示例任务，并使用scheduleTask函数调度它们：

func main() {
  // 连接数据库
  db, err := sql.Open("mysql", "用户名:密码@tcp(localhost:3306)/数据库名")
  if err != nil {
    log.Fatal(err)
  }
  defer db.Close()

  // 调度任务
  scheduleTask(db, "Task 1", time.Now().Add(10*time.Second))
  scheduleTask(db, "Task 2", time.Now().Add(20*time.Second))

  // 等待任务完成
  time.Sleep(30 * time.Second)
}

以上代码中，我们使用time.Now().Addrrreee

Ensuite, nous pouvons utiliser le code suivant pour nous connecter à la base de données MySQL :

rrreee

Créer une tâche planifiée🎜🎜Ensuite, nous allons utilisez le package time du langage Go et goroutine pour créer des tâches planifiées. Tout d’abord, nous devons écrire une fonction pour exécuter une logique de tâche spécifique. Par exemple, le code suivant définit une logique de tâche simple, qui affiche le nom de la tâche et l'heure actuelle : 🎜rrreee🎜 Ensuite, nous pouvons utiliser le code suivant pour créer une tâche planifiée à exécuter à l'heure spécifiée : 🎜rrreee🎜Dans le ci-dessus le code, insérez d'abord les informations sur la tâche dans la base de données, puis calculez la différence de temps entre l'heure actuelle et l'heure d'exécution de la tâche, utilisez la fonction time.AfterFunc pour créer une minuterie et exécutez la logique de la tâche après l'heure spécifiée. Avant et après l'exécution de la tâche, nous mettons également à jour le statut de la tâche. 🎜
🎜Planification des tâches🎜🎜🎜Maintenant, nous pouvons écrire une fonction pour planifier plusieurs tâches. Par exemple, le code suivant crée deux exemples de tâches et les planifie à l'aide de la fonction scheduleTask : 🎜rrreee🎜Dans le code ci-dessus, nous utilisons time.Now().Add fonction pour calculer le temps d’exécution prévu de la tâche. Après avoir planifié la tâche, nous mettons le programme en veille pendant 30 secondes et attendons la fin de l'exécution de la tâche. 🎜🎜Résumé : 🎜Cet article présente comment utiliser le langage MySQL et Go pour développer un système simple de planification de tâches. En créant des tables de base de données, en vous connectant à la base de données, en créant des tâches planifiées et en planifiant des tâches, nous pouvons gérer et exécuter différents types de tâches. Ce qui précède n’est qu’un exemple simple, la situation réelle peut être plus complexe. Cependant, en vous référant aux exemples de code de cet article, vous pouvez facilement étendre et personnaliser votre propre système de planification de tâches. 🎜

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!