Utiliser Redis pour implémenter des tâches planifiées distribuées en PHP

Redis est une base de données en mémoire hautes performances qui présente les avantages de vitesses de lecture et d'écriture rapides, prend en charge un certain niveau de persistance et des types de données riches. Redis est souvent utilisé dans des scénarios tels que la mise en cache, les files d'attente de messages et les classements en temps réel. Lors du développement, nous devons parfois implémenter des tâches planifiées distribuées, comme l'envoi d'emails, le nettoyage de fichiers temporaires, la mise à jour du cache, etc. Cet article explique comment utiliser Redis pour implémenter des tâches planifiées distribuées.

1. Types de données pris en charge par Redis

Les types de données pris en charge par Redis incluent : chaîne, hachage, liste, ensemble et ensemble ordonné. Lors de la mise en œuvre de tâches planifiées distribuées, nous nous concentrons principalement sur deux types de données : les ensembles ordonnés et les listes.

1. Ordered Set

Ordered set est un type de données fourni par Redis. Il est similaire à une table de hachage et peut stocker des paires clé-valeur, mais la valeur (également appelée score) peut être répétée et chaque valeur ​. ​sont associés à un score, et le score est utilisé pour le tri. Les éléments d'un ensemble ordonné sont triés du plus petit au plus grand par score.

Lorsque nous utilisons des ensembles ordonnés pour implémenter des tâches planifiées distribuées, nous pouvons utiliser le temps d'exécution de la tâche comme score, le contenu de la tâche comme valeur et enregistrer chaque tâche dans un ensemble ordonné.

2. List

List est un type de données fourni par Redis. Il est similaire à un tableau et peut ajouter et supprimer des éléments en tête ou en queue de la liste. Redis fournit une riche liste de commandes, telles que : lpush, rpush, lpop, rpop, etc.

Lorsque nous utilisons des listes pour implémenter des tâches planifiées distribuées, nous pouvons enregistrer le contenu de la tâche dans la liste et utiliser la commande lpop pour obtenir les tâches à exécuter.

2. Étapes pour implémenter des tâches de timing distribué

La mise en œuvre de tâches de timing distribué peut être grossièrement divisée en les étapes suivantes :

1. Ajoutez la tâche à l'ensemble ordonné et définissez le temps d'exécution de la tâche sous forme de score.
2. Démarrez un processus en arrière-plan pour analyser les tâches de la collection ordonnée, déterminez si la tâche doit être exécutée et ajoutez les tâches qui doivent être exécutées à la liste des tâches.
3. Démarrez plusieurs processus Worker et extrayez les tâches de la liste des tâches pour exécution.
4. Après l'exécution, supprimez la tâche de l'ensemble commandé.
5. Ajouter des tâches à un ensemble ordonné

Utilisez la commande suivante pour ajouter des tâches à un ensemble ordonné :

ZADD tâches timestamp content

Où, tâches est le nom de l'ensemble ordonné et horodatage est l'heure d'exécution de l'ensemble ordonné. tâche (horodatage Unix), le contenu est le contenu de la tâche.

Par exemple, pour ajouter une tâche "Envoyer un courrier" à la collection commandée, après que le temps d'exécution soit de 10 minutes, vous pouvez utiliser la commande suivante :

ZADD tâches $(date -d "+10 minutes" +%s ) "envoyer un e-mail"

2. Analyser les tâches dans l'ensemble trié

Démarrez un processus en arrière-plan et utilisez la commande suivante pour obtenir toutes les tâches qui doivent être exécutées à partir de l'ensemble trié :

ZRANGEBYSCORE tâches -inf $(date +%s) WITHSCORES

Parmi eux, -inf représente la valeur minimale dans l'ensemble ordonné et $(date +%s) représente l'horodatage Unix de l'heure actuelle.

La commande ci-dessus renverra une liste avec des scores, par exemple :

1) "effacer les fichiers temporaires"
2) "1626387489"

où "effacer les fichiers temporaires" est le contenu de la tâche et "1626387489" est l'exécution du temps de la tâche.

Après avoir obtenu toutes les tâches à effectuer, ajoutez ces tâches à la liste des tâches.

3. Exécuter des tâches

Démarrez plusieurs processus Worker et affichez les tâches de la liste des tâches pour exécution. Après exécution, la tâche est supprimée de l'ensemble ordonné.

Utilisez la commande suivante pour extraire une tâche de la liste et l'exécuter :

lpop tâches

où tâches est le nom de la liste.

4. Supprimer une tâche d'un ensemble ordonné

Une fois la tâche exécutée, utilisez la commande suivante pour supprimer la tâche de l'ensemble ordonné :

Contenu des tâches ZREM

où, tâches est le nom de l'ensemble ordonné, le contenu est le contenu de la tâche.

3. Implémentation du code

Ci-dessous, nous utilisons PHP pour implémenter les étapes ci-dessus.

1. Ajouter des tâches à un ensemble ordonné

Utilisez le code suivant pour ajouter des tâches à un ensemble ordonné :

$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

// 添加任务到有序集合
$timestamp = strtotime("+10 minutes");
$redis->zAdd('tasks', $timestamp, 'send email');

2. Analyser les tâches dans un ensemble ordonné

Utilisez le code suivant pour analyser un ensemble ordonné de tâches et ajouter les tâches qui doivent être exécutées dans la liste des tâches :

while(true) {
    // 扫描有序集合中的任务
    $scoreTasks = $redis->zRangeByScore('tasks', '-inf', time(), array('withscores' => true));
    foreach($scoreTasks as $task => $score) {
        // 将需要执行的任务添加到任务列表中
        $redis->lpush('task_list', $task);
        // 将任务从有序集合中删除
        $redis->zRem('tasks', $task);
    }
    // 每隔5秒扫描一次
    sleep(5);
}

3. Exécuter des tâches

Utilisez le code suivant pour démarrer plusieurs processus Worker et faire apparaître les tâches de la liste des tâches pour exécution :

$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

for($i=0; $i<10; $i++) {
    // 启动10个Worker进程
    $pid = pcntl_fork();
    if($pid == -1) {
        echo 'fork error!' . PHP_EOL;
        exit;
    } else if($pid == 0) {
        // 子进程中获取任务列表中的任务并执行
        while(true) {
            // 从列表中弹出一条任务
            $task = $redis->rpop('task_list');
            if(empty($task)) {
                continue;
            }
            // 执行任务
            mail('user@example.com', 'Task', $task);
        }
    }
}

Résumé

Ce qui précède. sont les étapes et l'implémentation du code de l'utilisation de Redis pour implémenter des tâches planifiées distribuées. L'utilisation de Redis peut facilement mettre en œuvre la planification de tâches distribuées et améliorer les capacités de traitement simultané et l'efficacité d'exécution des tâches. Dans les applications réelles, nous devons optimiser le code en fonction de la situation réelle, par exemple en utilisant des verrous pour effectuer un accès mutuellement exclusif à la liste des tâches, en utilisant des minuteries pour obtenir des tâches régulièrement, etc.

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!