Calcul simultanné de moyennes en temps réel.

Bonjour, Je travail sur une application graphique qui affiche 6 courbes super posées. Deux curseurs peuvent être déplacé par l'utilisateur sur l'axe des abscisses. Mon probleme : Je voudrais calculer et afficher, en temps réel, la moyenne entre les deux curseurs pour chacune des courbes, à mesure que les curseurs sont déplacés. Je commence me débrouiller en interface graphique (enfin je crois), mais je suis totalement débutant pour ce qui est du calcul en Java, ainsi que tout ce qui est thread. Comme j'ai 6 courbes et donc 6 moyenne a calculer est ce que je dois utiliser les threads. Quel est leur avantage? Comment ca marche en gros ? Merci à vous, J'aurais peut être d'autre question mais pour l'instant c'est tout ce qui me vient.

Bonjour,
Tu peux tout a fait calculer ces moyennes dans un thread... C'est une bonne solution car sinon pendant le calcul ton ihm sera bloquée. Une fois le calcul terminé tu met a jours le champs graphique mais pas depuis le thread sinon tu vas te prendre une exception du genre illégal access exception.
Avec la SWT il existe une méthode qui permet de faire ça depuis un autre thread Display#asyncExec(Runnable r) mais avec la swing je ne sais pas.
Bon courage, en tout cas avec les threads il faut se méfier de l'interblocage.
Cordialement,
Pierrick HYMBERT

Ok merci, ca me donne une première idées. Tu dis " Tu peux tout a fait calculer ces moyennes dans un thread..." Je pensais plutôt calculer chaque moyenne dans un thread séparé. En fait j'ai d'autre valeurs statistiques à calculer de la même manière que la moyenne. Genre la regression linéaire et d'autre trucs plus compliqués, en tout 5 ou 6 calculs différents qui doivent être effectués pour chacune des 6 courbes. Je pensais faire ca comme ca : un thread de calcul par courbe et chaque thread calcule toute les valeurs statistique pour la courbe qui le concerne. Ou est ce qu'il vaut mieux faire un thread par type de valeur, et chaque thread calcule pour toute les coubes ? J'ai l'impression que je m'attaque a un problème plutôt coriace sachant qu'il faut que j'obtienne les meilleur temps de réponse possible. Qu'est ce que vous en penser.

C'est bon mon problème est résolu. J'ai utilisé un adapter pour chaque courbe. Cette adapter écoute les deux curseur. Dès qu'il y a du mouvement il demande au modele (contenant les données de la courbe) de calculer les statistiques sélectionnées, puius il les envoie à la vue qui affiche affiche la courbe avec les statistiques calculées. Ca marche bien, et ce n'est pas trop trop lent, mais je n'ai pas encore éssayé avec toutes les statistiques. Si vous voyez une autre méthode je suis toujours preneur. J'ai aussi une question, je ne sais pas trop comment fonctionnent les listener. Dans mon cas, un listener par courbe, est-ce qu'il y'a plusieurs threads de créés, un par listener, ou non ?

non un listener ne creer pas de thread

un listener est un 'ecouteur' que tu abonne a une source, c est la source qui va scanner tout les listener qui se sont abonné et leur donne la main en fournissant l evenement en cour... ;o) donc le temps d execution et pris sur le fonctionnement de la source (le thread)...

j espere avoir etait clair ;o) ?!! c est un mécanisme asser simple mais tres éfficasse ;o) et cela permet bcp de liberté qd à la gestion des ecouteur ;o) tu peux facilement choisir un ecouteur pour toute tes sources ou un ecouteur par sources ;o) ....

GL ++


GodConan ;o)

Pour ce qui est du ralentissement dû à l'utilisation de plusieurs threads, je ne suis pas convaincu. De plus en plus de processeurs sont multi-coeurs et donc font tourner plus vite les application multi-threadées. J'ai développé un petit benchmark qui réalise un calcul lourd divisé en petites tâches. On peut choisir le nombre de threads utilisés pour le calcul ainsi que les contraintes de synchronisation. Le résultat à partir de Java 1.5 m'a agréablement surpris : jusqu'à 32 threads les résultats vont en s'améliorant à partir du moment où les synchronisations ne sont pas trop nombreuses (et ce, même sur un simple coeur!). Voilà pourquoi j'encouragerai fortement les programmeurs à utiliser le multi-threading (le pattern Active Object permet une implémentation propre).