Avis sur la bonne utilisation des Threads
Bonjour,
Je n'ai pas l'habitude de travailler avec les threads. c'est donc un domaine que je ne maitrise pas bien. J'aimerais donc bien, sans vouloir abuser, vous soumettre une archi et que vous me donniez votre avis. Merci.
Le contexte est le suivante :
Une servlet doit interroger un à x webservices que l'on appelle ici Enabler.
Les contraintes sont les suivantes :
Les webservices doivent être interrogés en parrallèle et non en séquentiel pour optimiser le temps de traitement de la servlet.
Pour chaque enabler on renseigne un timeout qui correspond à un temps de traitement maximum. Si ce timeout est dépassé, la servlet continu son traitement sans attendre la retour du webservice.
L'architecture que j'ai imaginé pour répondre à ce besoin est la suivante :
- une classe AbstractEnabler
Cette classe abstraite hérite de Thread. La méthode run() est déclarée en final et des méthodes abstarites get() et set() sont déclarées (les méthodes set() et get() correspondent aux 2 types d'actions qu'il est possible de faire dans chaque enabler).
Cette classe AbstractEnabler sert de base à la conception des enablers qui vont être appellés dans mes servlets.
- une classe EnablerRunner
Cette classe hérite également de Thread. Comme son nom l'indique cette classe va servir a exécuter les différents Enabler. Le Runner va également s'assurer que le traitement de l'Enabler ne dépasse pas la durée du timeout.
On a donc 1 servlet qui va lancer 1 à x EnablerRunner et chaque EnablerRunner va lancer une classe héritant d'AbstractEnabler.
Mes premiers tests en local semblent concluant et j'ai quelque chose qui répond à ce qui a été demandé. Maintenant, comme je vous l'ai dit, je ne maitrise pas bien les threads et je me demande si il n'y a pas moyen de faire cela en une seule classe?
Si ca vous interresse, voici le code.
la classe AbstractEnabler :
Code:
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
public abstract class AbstractEnabler extends Thread /*implements Runnable*/ {
private String server = "127.0.0.1";
private int port = 8080;
private int timeout = 0;
private int activation = 1;
protected Logger log = FileLogger.getLogger(this.getClass());
/**
* Constructeur vide
*
*/
public AbstractEnabler() {
}
/**
* Initialise l'enabler avec ses différentes propriétés
*
* @param name
* le nom
* @param server
* le server (adresse IP ou nom réseau)
* @param port
* le port
* @param timeout
* le timeout
* @param activation
* 1 l'enabler est actif, 0 il est inactif
*/
public AbstractEnabler(String name, String server, int port, int timeout, int activation) {
super();
setName(name);
setServer(server);
setPort(port);
setTimeout(timeout);
setActivation(activation);
debug();
}
/**
* Initialise l'enabler avec EnablerDefinition
*
* @param definition
* l'objet EnablerDefinition
*/
public AbstractEnabler(EnablerDefinition definition) {
setName(definition.getName());
setServer(definition.getServer());
setPort(definition.getPort());
setTimeout(definition.getTimeout());
setActivation(definition.getActivation());
debug();
}
/**
* ici se trouvent normalement les getters et les setters
*/
private void debug() {
log.debug("le nom de cet enabler est : " + this.getName());
log.debug("le serveur de cet enabler est : " + this.getServer());
log.debug("le port de cet enabler est : " + this.getPort());
log.debug("le timeout de cet enabler est : " + this.getTimeout());
log.debug("le flag activation de cet enabler est : " + this.getActivation());
}
/**
* @see java.lang.Runnable#run()
*/
public final void run() {
// je force le get() pour les tests
this.get();
}
public abstract void set();
public abstract void get(); |
la classe EnablerRunner :
Code:
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
37
38
39
40
41
42
43
44
|
public class EnablerRunner extends Thread {
private AbstractEnabler enablerThread;
private Logger log = FileLogger.getLogger(this.getClass());
public EnablerRunner(AbstractEnabler enabler) {
enablerThread = enabler;
}
/**
* @see java.lang.Runnable#run()
*/
public void run() {
try {
log.debug("Démarrage du Thread " + enablerThread.getName() + ".");
enablerThread.start();
log.debug("Le Thread " + enablerThread.getName() + " est démarré.");
if (enablerThread.getTimeout() > 0) {
log.debug("Le Thread " + enablerThread.getName() + " a un timeout de " + enablerThread.getTimeout() + " millisecondes.");
// on attend la fin du thread enabler pour une durée au maximum égale
// au timeout (en millisecondes)
enablerThread.join(enablerThread.getTimeout());
if (enablerThread.isAlive()) {
log.debug("Interruption du Thread " + enablerThread.getName() + ".");
enablerThread.interrupt();
enablerThread = null;
}
}
if (enablerThread != null) {
log.debug("Le Thread " + enablerThread.getName() + " est terminé.");
}
} catch (InterruptedException e) {
log.debug("Thread " + enablerThread.getName() + " interrompu.");
e.printStackTrace();
}
}
} |
et voici cmment je teste :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class TestDefaultEnabler {
/**
* @param args
*/
public static void main(String[] args) {
EnablerDefinition definition = Configuration.getInstance().getEnablerDefinition("URM");
AbstractEnabler enabler = new DefaultEnabler(definition);
EnablerRunner runner = new EnablerRunner(enabler);
runner.start();
}
} |
merci à ceux qui prendront le temps de me lire.
