Discussion :

[TekP@f]

Salut,

J'ai développé un gestionnaire de tâches qui marche sans problème. Le principe est le suivant :
- dans une table MySQL sont enregistrées des demandes de traitement
- j'ai une application principale qui boucle sans fin sur la lecture de cette table
- dès qu'une demande est détectée, un thread est créé qui traite cette demande
- pour ne par trop accéder à la base, j'ai mis un wait de 2 secondes entre chaque itération de la boucle sans fin


Ca marche bien, mais je me pose certaines questions sur une future mise en production. N'y aura-t-il pas de problèmes de ressources processeur avec une application qui tourne sans fin ?

J'essaie de trouver une méthode pour endormir l'application principale et la réveiller uniquement lorsqu'un nouvel enregistrement est détecté, mais je ne vois pas trop comment faire.
Des idées ?

[Netwak]

Bonjour,

L'idée principale d'attendre un autre Thread est déjà implanté dans Thread. Il s'agit de wait(), notify() et notifyAll(). Regarde comment tu peux intégrer sa dans ton code mais je pense que ce sera beaucoup mieux qu'un Tread.sleep. Par contre tu peux le laisser pour éviter des appels intempestive à ta base de données.

Netwak.

[TekP@f]

J'ai dû mal m'expliquer là.

Mon programme principal n'attend pas la fin d'exécution d'autres threads mais l'insertion de nouvelles tâches dans une base de données.
Or, à ma connaissance, il n'existe pas de SGBD qui sache réveiller une application. D'où ma boucle sur le programme principale.

Mon code source :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
public class Server {
 
	public static void main(String[] args) throws Exception {
	    try
	    {
	    	while (true){
				// Récupération des demandes de traitement
				List objResult = TaskMetier.search(1);
 
		        // Traitement des tâches détectées
		        Task objTask;
		        for (int i = 0; i < objResult.size(); i++) {
		        	objTask = (Task)objResult.get(i);
		        	System.out.println("Traitement de la tâche n°" + objTask.getIntIdTask());
		        	// Traitement d'une tâche
		        	new ServerThread(objTask.getId());
		        }
		        Thread.sleep(1000);
			}
	    }
	    catch (Exception e) { throw e;
	    }
 
	}
}

Le truc qui me gêne, c'est que ce programme va boucle sans fin.

[TekP@f]

Mon problème vient de changer d'orientation.

J'ai créé une méthode sur mon gestionnaire de tâches qui exécute toutes les tâches d'un parent et qui ne rend la main qu'une fois ces tâches terminées.

Dans l'application parente, après l'insertion des tâches en base de données, j'ai ajouté l'appel à cette fonction.

Un peu de code ...
Le gestionnaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
public static void videPileInstance(long ID_) throws Exception {
	    try
	    {
	    	System.out.println("Début vidage instance n° " + ID_);
 
	    	List objResult = TaskMetier.search(1, ID_);
	    	ServerThread[] tabThread = new ServerThread[1];
 
	    	// Traitement des tâches détectées
	        Task objTask;
	        for (int i = 0; i < objResult.size(); i++) {
	        	objTask = (Task)objResult.get(i);
	        	System.out.println("Création thread n°" + objTask.getIntIdTask());
	        	tabThread[i] = new ServerThread(objTask.getIntIdTask(), Integer.parseInt(objTask.getStrParam()));
	        }
 
	        for (int i = 0 ; i < tabThread.length ; i ++) tabThread [i].start () ;
	        for (int i = 0 ; i < tabThread.length ; i ++) {
	          try {
	        	  System.out.println("Attente thread n°" + tabThread [i].getIdTask());
	        	  tabThread [i].join () ;
	          } catch (InterruptedException e) {
	            System.out.println ("InterruptedException sur " + tabThread [i].getIdTask()) ;
	          }
	        }
	        System.out.println ("Fin du vidage") ;
 
 
	    }
	    catch (Exception e) { 
	    	e.printStackTrace();
	    	throw e;
	    }
 
	}

Le parent :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Server.videPileInstance(intIdInstance);

De cette façon, mon gestionnaire est appelé uniquement si besoin. Mais maintenant, je me retrouve avec le problème que je voulais éviter au départ : la dépendance entre les 2 projets.

Le projet parent est quasiment figé, il a très peu de maintenance car il est appelé sans cesse en production. Donc faut éviter de le faire tomber.

Par contre, le gestionnaire va connaître une maintenance régulière selon l'arrivée de nouveaux clients et donc de nouveaux types de tâches.

D'où mon problème : comment faire une maintenance à chaud ? Mon application parent dépend du JAR du gestionnaire. Comment recharger ce JAR pendant que le parent tourne ?

Merci de votre aide

[verbose]

La technologie Osgi est toute désignée pour résoudre ton problème. Elle permet justement de brancher et débrancher des librairies à chaud. Par contre, cela va t'obliger à réécrire partiellement ton parent pour qu'il utilise le conteneur Osgi.

http://www.humbertocervantes.net/osgitutorial/main.htm

[Djobird]

Au lieu d'envoyer directement les ajouts dans ta base de données, tu les envois à un composant qui va se charger d'envoyer la requête à la base, et de notifier de cette ajout tous les composants qui s'était enregistrés à lui.

[TekP@f]

Au lieu d'envoyer directement les ajouts dans ta base de données, et les envois à composant qui va se charger d'envoyer la requête, et de notifier de cette ajout tous les composants qui s'était enregistrés à lui.

Heu désolé, mais je ne comprends pas du tout ta réponse. Tu pourrais reformuler ...

[Netwak]

En gros, ce que moi j'ai compris, c'est que plutôt que d'utiliser ta base de donnés pour recevoir les requêtes, envoie les à un composant de ton application qui se chargera de tout le travail.

Mais ton but d'envoyer a une base de donnés la liste des tâches peut se comprendre si les tâches sont reçut par plusieurs postes. Cependant ici un servlet s'impose.

Donne nous plus de détail de tes contraintes pour que l'on te donne d'autre solution que d'utiliser ta base de donnés de manière inutile (la base de donnés c'est lourd, même un xml est mieux dans ton cas).

[TekP@f]

Plus de détails :

J'ai un servlet qui reçoit des requêtes de différents postes (mobiles, PC ...). La réponse à ces requêtes est définie grâce à un workflow associé à chaque type de requête. Ce workflow est pour simplifier une succession de tâches à exécuter.

L'exécution de ces tâches est déportée dans un gestionnaire de tâches. La communication entre ces 2 programmes se fait via une table SQL.

Donc, le workflow insère ses tâches dans la table, le gestionnaire lit la table et les traite.

C'est moi qui ai mis en place ce système. La raison de la séparation du workflow du gestionnaire est due à la maintenance. Le gestionnaire sera mis à jour régulièrement. Mais cette mise à jour ne devra pas stopper le service assuré par le workflow. D'où la séparation.

De plus, j'avais pensé au départ gérer les tâches via une file d'attente interne (List ou HashMap) mais la persistance n'est pas gérée en cas de redémarrage du gestionnaire de tâches. D'où l'utilisation d'une bdd.
Et le XML, je trouve ça plus lourd et plus lent qu'une bdd. J'ai du mal à croire que ce soit plus facile dans mon cas ?

[Netwak]

Pour ton problème, tu peux continuer à utiliser une BDD. Par contre, au lieu de vérifier continuellement la BDD, tu peux mettre un moyen de communication entre les deux parties, pour indiquer les changement de base de données. La séparation peut se faire avec une interface ou par un pattern plus évolué, et alors cela ne gênera pas la maintenance.

[TekP@f]

Je viens de mettre une interface en place. Ca le fait bien.
Merci pour votre aide.