Nodejs implémente la file d'attente de retard

Node.js implémente la file d'attente différée

La file d'attente différée fait référence à une file d'attente qui exécute une tâche après une certaine période de temps. Dans de nombreux scénarios, nous devons effectuer certaines tâches à un moment donné dans le futur, comme la mise en œuvre de tâches planifiées. Dans Node.js, nous pouvons utiliser des files d'attente à retard pour répondre à de tels besoins. Cet article explique comment utiliser Node.js pour implémenter des files d'attente à retard.

1. Méthodes d'implémentation

Il existe deux manières couramment utilisées pour implémenter des files d'attente de retard dans Node.js :

• Utilisez la fonction setTimeout
• Utilisez la fonction setInterval

Lors de l'utilisation de la fonction setTimeout, nous pouvons utiliser des appels récursifs moyen d'obtenir une exécution différée. Plus précisément, après l'exécution de chaque tâche, le délai de la tâche suivante est calculé en fonction du décalage horaire de la tâche suivante, puis la fonction setTimeout est utilisée pour exécuter la tâche suivante.

Lors de l'utilisation de la fonction setInterval, nous devons utiliser une minuterie pour enregistrer l'heure de début de chaque tâche, calculer l'heure de début de la tâche suivante, puis calculer le retard de la tâche suivante en fonction du décalage horaire.

Cet article présente principalement la méthode d'implémentation de la première méthode, qui consiste à utiliser la fonction setTimeout pour implémenter la file d'attente différée.

2. Code d'implémentation

Ce qui suit est l'implémentation du code utilisant la fonction setTimeout pour implémenter la file d'attente de retard :

const tasks = [];
let delay = 0;

const schedule = (task, time) => {
  tasks.push(() => {
    setTimeout(() => {
      console.log(`${new Date()} - Task ${task} executed`);
    }, time);
  });
};

const runTasks = () => {
  if (!tasks.length) {
    console.log('All tasks completed');
    return;
  }

  const task = tasks.shift();
  task();
  delay += 1000;
  setTimeout(runTasks, delay);
};

schedule(1, 1000);
schedule(2, 5000);
schedule(3, 3000);

runTasks();

Dans le code ci-dessus, nous définissons d'abord un tableau tâches pour stocker le délai requis tâches à accomplir. Ensuite, une variable delay est définie pour enregistrer le temps de retard total de la tâche afin que la tâche suivante puisse être correctement retardée. tasks，用于存储需要延时执行的任务。然后定义了一个变量 delay，用于记录任务的延时总时间，以便下一个任务能够正确的延时执行。

接着，我们定义了一个 schedule 函数，用于将任务添加到 tasks 数组中，并根据时间差计算出任务延时的时间。

最后，我们定义了一个 runTasks 函数，用于递归地执行延时任务。在每次执行任务时，我们首先从 tasks 数组中取出第一个任务，并执行该任务。同时，该任务会添加到 delay 变量中，以便下一个任务能够正确的计算延时时间。在每次执行任务后，我们都会使用 setTimeout 函数去执行下一个任务，延时时间为当前的 delay 值。

3. 测试代码

下面是测试上面代码的测试代码：

console.log(`${new Date()} - Start`);

const tasks = [];
let delay = 0;

const schedule = (task, time) => {
  tasks.push(() => {
    setTimeout(() => {
      console.log(`${new Date()} - Task ${task} executed`);
    }, time);
  });
};

const runTasks = () => {
  if (!tasks.length) {
    console.log('All tasks completed');
    return;
  }

  const task = tasks.shift();
  task();
  delay += 1000;
  setTimeout(runTasks, delay);
};

schedule(1, 1000);
schedule(2, 5000);
schedule(3, 3000);

runTasks();

上面的测试代码中，我们使用 console.log

Ensuite, nous définissons une fonction schedule pour ajouter des tâches au tableau tasks et calculons le temps de retard des tâches en fonction du décalage horaire.

4. Enfin, nous définissons une fonction runTasks pour exécuter de manière récursive des tâches retardées. Chaque fois qu'une tâche est exécutée, nous prenons d'abord la première tâche du tableau tasks et l'exécutons. Dans le même temps, la tâche sera ajoutée à la variable delay afin que la tâche suivante puisse calculer correctement le temps de retard. Une fois chaque tâche exécutée, nous utiliserons la fonction setTimeout pour exécuter la tâche suivante, et le temps de retard est la valeur delay actuelle.
Code de test
🎜Ce qui suit est le code de test pour tester le code ci-dessus : 🎜rrreee🎜Dans le code de test ci-dessus, nous utilisons la fonction console.log pour exécuter la tâche Journaux de sortie pour vérifier que la tâche s'est exécutée comme prévu. 🎜🎜🎜Résumé🎜🎜🎜Grâce à l'introduction ci-dessus et à l'implémentation du code, nous avons appris à utiliser la fonction setTimeout pour implémenter une file d'attente de retard dans Node.js. L'utilisation de files d'attente peut nous aider à mettre en œuvre certains scénarios nécessitant l'exécution de tâches à un certain moment dans le futur, tels que des tâches planifiées, des mécanismes de nouvelle tentative, etc. Dans le développement réel, nous pouvons choisir une méthode d'implémentation appropriée en fonction de scénarios spécifiques et la combiner avec du code de test pour vérifier si notre implémentation fonctionne comme prévu. 🎜

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!