malek20
Messages postés3Date d'inscriptiondimanche 10 août 2014StatutMembreDernière intervention 7 septembre 2014
-
6 sept. 2014 à 14:37
KX
Messages postés16733Date d'inscriptionsamedi 31 mai 2008StatutModérateurDernière intervention31 janvier 2024
-
11 sept. 2014 à 19:32
Bonjour,
Mon application est un site web lors de la deconnexion de l'utilisateur j'ai un traitement à faire avant le rediriger vers la page d'acceuil(page connexion).
Ce traitement prend 30min parfois plus dc ce n'est pas logique pour l'utilisateur d'attendre 30min pour qu'il se deconnecte .donc je voulais qu'il doit etre rediriger
vers page d'acceuil alors que le traitement soit faite en arrière plan.
Sincerement j'ai jamais travaillé avec les threads mais j'ai lis quelques cours .
j'ai essyé ce bout de code:
une classe MonThread6 qui gere le traitement.
une classe Monthread3 qui contient la redirection .
public class MonThread6 extends Thread { private boolean actif = true;
public static void main(String[] args) { try { MonThread6 t = new MonThread6(); t.start(); System.in.read(); t.arreter(); } catch (Exception e) { e.printStackTrace(); }
}
public void run() { int i = 0; while (actif) { /*traitement*/ } }
public void arreter() { actif = false; } }
public class Monthread3 { private boolean actif = true; private HttpServletResponse response; public Monthread3(HttpServletResponse resp) { response=resp; }
public void run() { try { response.sendRedirect("/Projet/connexion");
KX
Messages postés16733Date d'inscriptionsamedi 31 mai 2008StatutModérateurDernière intervention31 janvier 2024127 6 sept. 2014 à 14:57
Bonjour,
Si tu as plusieurs utilisateurs, ou le même utilisateur qui se connecte/déconnecte plusieurs fois tu vas avoir de multiples thread qui tournent en même temps, jusqu'à en avoir trop et faire planter ton serveur.
Une opération de 30 minutes par déconnexion semble anormalement longue et il y aurait sûrement des trucs à revoir pour diminuer ce temps, mais en tous les cas tu dois limiter le nombre de threads qui vont être exécutés en parallèle.
Pour cela tu devrais créer un pool de thread, voir la classe Executors, ainsi si la limite de threads est atteinte, l'exécution de 30 minutes est reportée jusqu'à la ce qu'un nouveau thread soit disponible.
Il faudra bien sûr dimensionner correctement la taille du pool pour ne pas accumuler trop de retard (d'où l'intérêt de réduire les 30 minutes), mais par exemple avec 100 thread dans ton pool, tu peux gérer 4800 déconnexions par jour, avec éventuellement certains traitements qui s'exécuteront pendant les heures creuses où personne ne s'est déconnecté, mais où l'on rattrape le retard à traiter des déconnexions qui étaient en attente.
Bonjour,
merci pour votre reponse.
J'ai déjà essayé de minimiser le temps mais le problème c'est que j'utilise des API dont je peux plus minimiser leur temp de traitement.
Alors pour executors comment je peux identifier la tache que se derroule en arrière plan de l'autre qu'on doit la voir??
KX
Messages postés16733Date d'inscriptionsamedi 31 mai 2008StatutModérateurDernière intervention31 janvier 2024127 7 sept. 2014 à 22:18
"identifier la tache que se derroule en arrière plan de l'autre qu'on doit la voir" Je ne comprends pas trop ce que tu veux dire, avec les ExecutorService toutes les tâches du pool seront en arrière plan.
cormandyr
Messages postés600Date d'inscriptionsamedi 20 mai 2006StatutMembreDernière intervention 8 juillet 201611 11 sept. 2014 à 13:58
Bonjour,
si tu ne peux pas diminuer le temps de processing, tu peux peut-être partitionner le processing... si tout le processing prend 30minutes, tu peux peux-être avec 3 processus de 10minutes (en fonction des taches à faire)
Mais bien sur cela dépend de ce qui doit être fais après la déconnexion de l'utilisateur...
KX
Messages postés16733Date d'inscriptionsamedi 31 mai 2008StatutModérateurDernière intervention31 janvier 2024127 Modifié par KX le 11/09/2014 à 20:08
Il faudra cependant faire très attention dans ce cas à ce que les étapes soit totalement indépendantes, et surtout qu'elles ne créent pas elles même de nouveaux threads. Dans le cas contraire, on peut se retrouver avec des cas d'interblocages lié à la taille limite du pool de thread.
En gros, on a démarré le max de thread disponible, et pour terminer n'importe laquelle de ces tâches il faudrait avoir un thread de plus. Mais comme il n'y a plus aucun thread disponible aucune tâche ne peut se terminer. Il faut alors tuer un ou plusieurs threads (on perd donc des données) pour qu'ils puissent être affectés à une tâche qui pourra alors se terminer et libérer à son tour ses threads (ou en créer de nouveaux et bloquer encore le processus...)
Si par contre c'est bien fait, chaque thread se termine toujours par une libération de lui même donc on est sûr que même si le maximum de threads est atteint celui-ci pourra se résorber sans problème.