Découpage en Multi thread

Bonjour,

J'ai réalisé une application qui:
- Ouvre un fichier
- lie le fichier
- Extrait des données
- test auprès d'un base SQL si les données existes déjà
- Ajout la données à la base.
...
puis refais l'étape 1...

Mon appli fonctionne très bien mais et elle est lente car tout est dans un thread.
J'aimerais découper mon programme en plusieurs thread:
- un qui ouvre le fichier
- un qui extrait les données
- un qui gere la base de données


Probleme, je connais mal le fonctionnement multi threadé.
Je pense faire communiquer le 1er et 2 thread par socet, mais puis je transmettre de grosse donner (des fichier entiere 1Mo max) par socket.
Entre le second thread et le troisieme, il me faut que les appels soit bloquant car on attend des réponses.
Je pense faire des wait et notif. Mais est ce que je suis sur le bon chemin ?

Enfin, si tout et bon, jaimerais avoir plusieurs instance du 1er et second thread pour aller plus vite. Comment puis je bien quantifier le nombre de thread max pour des performances optimale sans que ca impact le comportement (qu'il n'ai pas de conflit)

Merci davance !

http://java.developpez.com/faq/java/...angage_threads

J'ai déjà lu le faq, mon application étant déjà un thread.
Mon problème est plus lié à l'archtecture à adopter pour les multi thread.

Tu as manifestement besoin de lire un tutorial ou une faq sur le sujet comme le mentionne PierreD87.

Une chose cependant. Les threads partagent le même espace mémoire. Nul besoin donc d'utiliser les sockets pour échanger des données entre les threads. Il faut partager des objets entre tes threads. Evidemment, ce partage ne doit pas se faire n'importe comment au risque de laisser tes données dans un état incohérent. Pour cela, il faut utiliser "synchronized" ainsi que les méthodes "wait/notify" qui mettent en oeuvre la notion de moniteur.

Lis un tuto donc et reviens avec des questions précises si tu as des soucis.

En faite j'ai déjà lu plein de tutoriel, c'est comme ca que j'ai découvert wait/notify.
Je voulais juste faire valider mon architecture, et ne pas passé à coté de fonction qui aurait peuvent m'aider (comme les notify).
Bon je sais qu'il y a plus de codeurs, que d'architecture sur les forums mais bon...C'est pas grave, je vais coder et si jamais ca marche pas, ben je posterai un nouveau message en disant "ca marche pas pourquoi ? "

Citation:

---

Envoyé par laclac

En faite j'ai déjà lu plein de tutoriel, c'est comme ca que j'ai découvert wait/notify.
Je voulais juste faire valider mon architecture, et ne pas passé à coté de fonction qui aurait peuvent m'aider (comme les notify).
Bon je sais qu'il y a plus de codeurs, que d'architecture sur les forums mais bon...C'est pas grave, je vais coder et si jamais ca marche pas, ben je posterai un nouveau message en disant "ca marche pas pourquoi ? "

---

Faire valider ton archi ... tu exagères un peu là ... tu n'as pas vraiment exposer ton archi, tu as exposé quelques idées.

Alors, voilà quelques réponses ...

1) faire une thread pour ouvrir le fichier ??? je ne vois pas l'intérêt.

2) avoir une thread qui lit les données du fichier et les dépose dans un buffer pour qu'une autre thread aille consommer ces données du buffer pour les traiter me parait une bonne idée.
On est alors dans un schéma producteur/consommateur et tu peux effectivement utilsier wait/notify pour gérer l'accès au buffer.

Pour ce qui est d'utiliser plusieurs threads de production ... il faut que tu nous donnes plus d'informations pour que l'on puisse te répondre sur l'intérêt.

edit: par ailleurs, mon post précédent apportait déjà une réponse à une de tes questions.

il y a 2 manieres de decouper en thread :
- soit il s'agit de plusieurs taches completement différentes, mais qui peuvent s'exécuter en parallele : reseau, interface
- de nombreuses taches identiques : calcul, multiples clients sur un serveur

Après, il faut un peu d'expérience pour savoir comment découper :)

Postes donc ton architecture

Voilà donc mes explications detaillées mais qui doivent je pense etre ajusté (d'ou ma présence ici ;))

Je pense faire 3 catégories de thread:
:fleche: OuvrirFichiers: j'ai remarqué celà prenait beaucoup de temps (mes fichiers sont gros et sur le reseau). je pense en mettre 3 (pour donner un ordre de proportion). Un fois ouvert, mes threads mettent le fichier dans un buffer partagé de 2 cases. Les thread travaillent uniquement quand le buffer n'est pas plein via wait et notify.
:fleche: AnalyseDesFichiers: Ces threads (environs 4) lisent le buffer et analyse chaque fichier pour extraire les données .
durant l'analyse, ils incluent les données extraites dans le thread basededonnée.
:fleche: Basededonnée: au nombre de 1. Il communique avec la base de donnée SQL.
Elle implément Callable (appelé par newSingleThreadExecutor), ce qui permet aux threads AnalyseDesFichiers d'avoir les réponses aux requetes (isExiste(), AjouterData(), Supprimer(), isBlackLister()..).

Voilà en gros, l'idée !
A noter que je maitrise pas trop Callable et ce sont des notions qui sont encore flou pour moi.
Je pense sinon que normalement ca devrait marché.

Remarque:
- Un point et que la liste des fichiers a lire sont dans la base. Donc les thread OuvrirFichiers appel part le thread Basededonnée au debut par getnextFichier(). Par contre actuellement (en monothreader) je fais un

Code:

---

1 2 3 4

path = base.getnextFichierAVisiter(); ... base.ajouterPathVisité( path ); base.supprimerFichierAVisiter( path );

---

EN multithreader celà ne va pas fonctionner car 2 threads peuvent avoir le meme fichier. Dois je obligatoirement dans la fonction getnextFichierAVisiter(), automatiquement effacer de la liste le path retourner ?? (Pour éviter qu'un prochain appel retourne le meme path)
- "Un buffer partagé de 2 cases. Les thread travaillent uniquement quand le buffer n'est pas plein via wait et notify" , je ne sais pas encore comment notifier uniquement les threads qui ne travaillent pas :roll:. Dois je avoir un manager de thread ? J'ai entendu parler de pools de thread, est ce que celà peut résoudre mon probleme ?

Merci d'avance

Il te faut un objet qui va permettre à OuvrirFichiers et AnalyseDesFichiers de communiquer.
Je pense qu'il faut utiliser une FIFO de taille 2.
Tu peux implémenter le stockage comme tu veux.

Je pense à 2 méthode utiles pour cet objet : add(xxxxxx) et remove().
Ces 2 méthodes sont synchronized.

Pour la méthode add(), elle vérifie que ton objet n'est pas plein (2 fichiers).
Si l'objet n'est pas plein, elle l'ajoute, et signale aux AnalyseDesFichiers qu'il y a un fichier en attente par un this.notifyAll().
Si l'objet est plein, il faut que tu sois dans une boucle qui reessaye en continue, mais tu te mets en pause par un this.wait().

Pour la méthode remove(), tu procèdes comme pour le add(), en ajustant les this.wait() et this.notifyAll()

Bon, je n'ai pas de grandes connaissances en Threads, mais c'est comme ça que je ferai :p

Pour getnextFichierAVisiter(), il faut qu'elle soit synchronized, et qu'elle ne retourne pas la le même fichier lors de 2 appels successifs :p
Là, ça dépend trop de comment c'est fait ^^