Discussion :

[Péchereau]

Bonjour à tous,

j'ai une classe chargé de mettre à jour des informations pour un fond, un OPCVM, une SICAV (ça peut très bien être un client ou quelque chose d'autre).

Les méthodes de cette classe, par souci de simplification, sont statiques.

Bref ça doit ressembler à ça :

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
 
public class MaClasse{
 
static public void effectueTraitement(Dao monDao, int idFonds){
 
// quelques traitements prealables 
 
if(faireTraitement1Ou2){
effectueTraitementNo1(monDao, idFonds);
}else{
effectueTraitementNo2(monDao, idFonds);
}
}
 
static private effectueTraitementNo1(Dao monDao, int idFonds){
}
 
static private effectueTraitementNo2(Dao monDao, int idFonds){
}
}

Mon désir est de bloquer le traitement à effectuer pour UN fond, en cas de multithreading (on ne sait jamais).
Donc je ne veut pas ça :

Code :

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

1
2
 
static public synchronised void effectueTraitement(Dao monDao, int idFonds){

Mais plutôt ça :

Code :

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

1
2
3
4
5
6
7
 
static public void effectueTraitement(Dao monDao, int idFonds){
// trouver un objet pour se synchroniser
synchronised (monObjet){ // car "synchronised(idFonds)" ça ne marche pas
// ...
}
}

Alors ?
Comment faire ?

[Kh4iN3]

Salut,

Ben ta méthode étant static il suffit de déclarer un objet static :

Code :

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

1
2
3
4
5
6
7
8
 
private static Object mutex = new Object ();
...
static public void effectueTraitement(Dao monDao, int idFonds){
    synchronised (mutex) {
        // Tes traitements...
    }
}

Par contre je ne comprent pas pourquoi tu ne souhaite pas synchroniser la méthode complète...

Voila a+

[chtig]

Euh ... non là je pense que ta solution ne répond pas à la question...
En fait, il veut synchroniser toutes ses méthodes de traitement ensemble pour éviter qu'on puisse faire deux traitements sur le même id en même temps, c'est bien ça ?

Si c'est ça, alors effectivement c'est un peu embêtant car tu n'as pas un objet, mais un type primitif (id).

Il faudrait d'une certaine manière associer un objet à chaque id. Le problème, c'est la consommation mémoire, car je ne vois pas trop comment gérer la libération de ces objets (cad comment savoir qu'on a plus de thread en traitement sur cet id) ...

[Péchereau]

Oui c'est exactement ça ...
Eviter de faire que 2 threads fassent le même traitement sur le même id !!!

Et pourquoi pas ça :

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
 
 
static private Map mapMutexByID = new Hashtable();
 
static public void Object getMutexByIdFonds(int idFonds){
    Integer intId = new Integer(idFonds);
    if(!mapMutexByID.contains(intId){
        mapMutexByID .put(intId, new Object());
    }
    Object obj = mapMutexByID.get(intId);
}
 
static public void effectueTraitement(Dao monDao, int idFonds){
    synchronised (getMutexByIdFonds(idFonds)) {
        // Traitements...
    }
}

Qu'en pensez vous ?
Pour chaque idFonds, on n'instance qu'un objet et on le récupère pour l'utiliser comme Mutex.

[OButterlin]

Pourquoi pas

Code :

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

1
2
3
4
5
6
7
 
...
synchronized (tonObjet)
{
   ... le code ...         
}
...

[chtig]

@OButterlin : pas compris ...
@Péchereau : oui, ça peut marcher, à condition tout de même de synchroniser la méthode getMutexByIdFonds. Mais le souci c'est que si tu as des millions d'ids possibles tu vas te retrouver à terme avec des millions d'objets créés pour la synchro .... C'est ce que je voulais dire auparavant en disant qu'on ne sait pas quand les libérer.