CPU, utilisation de la mémoire, utilisation du pool de threads - Identité de base ASP NET non confirmée gestion de la suppression des utilisateurs de messagerie - Dans l'application ou dans une application séparée ?
Je me demande quelle est la solution la plus adaptée. Je dois implémenter un robot pour vérifier et supprimer les utilisateurs enregistrés non confirmés pendant, par exemple, 7 jours après l'envoi du courrier de confirmation. (Si un utilisateur ne confirme pas son compte, je veux supprimer l'utilisateur de la base de données). J'ai pensé à 3 façons :
- implémentez directement un délégué dans l'application principale ASP NET et exécutez-le en tant que tâche asynchrone dans une boucle avec une veille de 24 heures.
- créer une application console qui fonctionnera en boucle avec un sommeil de 24 heures
- créer une application console qui sera lancée régulièrement par un logiciel tiers (par exemple Cron ou TaskScheduler)
Laquelle de ces méthodes aura le moins d'impact sur l'utilisation du processeur et de la mémoire ?
De plus, le pool de threads a une quantité limitée à prendre, plus il y a de robots, moins il y a de threads pour les personnes essayant d'accéder à mon site Web ASP, ai-je raison ?
Et ma dernière question > est-ce une bonne idée de Thread.Sleep pendant si longtemps ? Quelque chose me dit que ce n'est vraiment pas le cas. D'autre part, c'est un ASP qui fonctionnera pendant des mois voire des années.
Quoi qu'il en soit, j'aime la vision d'avoir tout en une seule application (peut être configuré dans un seul fichier et tout commence en même temps). D'un autre côté, quelque chose me dit que ce n'est pas une super bonne idée.
Réponses
Lorsque la tâche est en cours d'exécution, je m'attendrais à ce que l'utilisation de la mémoire et du processus soit dominée par tout ce qui est requis pour la tâche, et devrait être comparable pour chaque méthode. Il devrait donc être plus intéressant de voir l'utilisation des ressources lorsqu'il n'est pas en cours d'exécution.
- En cours, à l'aide d'un timer (ou d'une
await Task.Delay(..)
boucle)
Cela ne nécessiterait que de la mémoire pour la minuterie ou la machine d'état asynchrone, et de la mémoire supplémentaire pour le code. Cela devrait être assez petit, peut-être quelques kilo-octets. Aucun temps processeur et aucun thread ne seraient utilisés en cas d'inactivité. Cela suppose que vous ne conservez pas de grandes structures de données.
- Dans un processus de console persistante distinct
Cela utiliserait quelques Mo de mémoire pour le runtime .Net, et de la mémoire supplémentaire pour le code et les données. En pratique, je m'attendrais à ce que la mémoire soit paginée sur le disque si l'ordinateur manque de mémoire. Aucun temps processeur ne serait utilisé en cas d'inactivité.
- Dans un processus de console planifié séparé
Cela ne consommerait de la mémoire que pour l'objet planificateur, et cela devrait être minime. De toute évidence, aucun temps processeur ou thread ne serait utilisé en cas d'inactivité.
Sommaire
la planification d'un processus séparé utiliserait le moins de ressources. Mais toutes les méthodes doivent utiliser une quantité de ressources assez insignifiante lorsqu'elles sont inactives. Je dirais donc que le choix devrait être fait sur d'autres critères, comme ce qui est le plus facile à maintenir et/ou à déployer.
Le pool de threads allouera plus de threads si nécessaire. Les threads ne doivent en général être utilisés que lorsqu'ils font réellement quelque chose (c'est-à-dire utiliser await task
au lieu de task.Wait()
), et vous aurez beaucoup plus de threads de pool de threads que de threads matériels. Je ne serais préoccupé par cela que si j'observais un nombre de threads beaucoup plus élevé que d'habitude.
J'éviterais Thread.Sleep
si possible. Une minuterie ou await Task.Delay
serait généralement plus approprié.