Thread et synchronized. besoin d'aide.

Bonjour j'aimerais votre aide pour sécuriser mon application car j'ai quelque problème.
J'ai une classe A qui est définir comme ceci en gros :

Code:

---

1 2 3 4 5 6

class A { private List<A> enfants ; private A parent ; .... }

---

Après, j'ai une classe avec que des méthode statique qui permette de
sauvegarder, afficher, mettre a jour le contenu de A et ses enfants et sous enfants.
par ex :

Code:

---

1 2 3 4 5 6 7

public static void afficher(A noeud) { noeud.toString(); for(int i=0;i<noeud.sizeEnfants();i++) { afficher(noeud.enfants(i); } }

---

Et pour finir, j'ai plusieurs Thread qui se lance à des moments différents.
un Thread pour 1 méthode statique.

Mais voilà le problème :
Deux méthode statique différente peuvent se retrouver dans le cas ou elle travaille sur le même objet. donc comment faire en forte que des qu'une méthode statique est appelée, les autre reste en attente, etc...

Exemple :
Le Thread A appel la méthode sauvegarder et place un point d'attente.
- Le Thread B lance la mise a jour mais il y a un point d'attente donc il attend.
- A viens de terminer sont traitement et vire le point d'attente.
- Le thread B commence la mise a jour et place un point d'attente.

Si tu veux que chaque méthode static soit en exclusion des autres (ou d'elle-même), il suffit de les mettre toutes synchronized...

Code:

---

public static synchronized void afficher(A noeud) {...}

---

D'accord, mais ceci ne marche que si ce sont deux Thread ou plus qui appel la même méthode non ?
Si les méthodes sont différentes et que nous voulons toutes les synchroniser ca marche aussi ?

Citation:

---

Envoyé par storm_2000

D'accord, mais ceci ne marche que si ce sont deux Thread ou plus qui appel la même méthode non ?
Si les méthodes sont différentes et que nous voulons toutes les synchroniser ca marche aussi ?

---

Oui car synchronized sur une méthode ça revient au même que synchronized(this) (donc le verrou est l'objet), et dans le cas des méthodes statiques ça revient au même que synchronized(TaClass.class).

http://rom.developpez.com/java-synchronisation/

Une autre solution nettement plus compliquée mais préférrée par certains programmeurs depuis son apparition en jdk 5.0 car rappellant très fortement la théorie de la concurence en base de données est l'utilisation de vérous. En gros ça se présente toujours de la même manière.

- Utiliser des objets de condition fournis par la classe ReentrantLock.
- initialiser un de ces objets dans la classe qui fournit les objets à protéger.
- protéger le code qui doit être synchronisé.

Le mot clé synchronized fournit brutalement l'objet de condition et synchronise toute la méthode. Les objets de condition permettent d'avoir un meilleur contrôle sur ce qu'on veut protéger. Voici ci-dessous un exemple d'une méthode de retrait d'argent, qui lance une exception si le montant demandé est négatif.

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

public class BankAccount { public BankAccount(double initialBalance) { this.balance = initialBalance; //solde initial du compte bancaire this.lock = new ReentrantLock(); //vérrou quis era associé à cet objet }   public void withdraw(double amount) { lock.lock(); //acquisition du verrou try { if(amount < 0) throw new IllegalArgumentException("amount must be positive"); balance -= amount; } finally { lock.unlock(); //relacher le verrou quoiqu'il arrive } }   private double balance; private ReentrantLock balance; }

---

Rq : ces verrous sont dits rentrants car un thread peut acquérir à plusieurs reprises un vérrou q'il possède déjà.


Une autre astuce en programmation avec thread est l'utilisations d'objets de condition, mais ce n'était pas ta question. Voilà sinon j'espère que tu as rélosu ton problème...

Plus d'explications dans ces cours Java : http://java.developpez.com/cours/

L'utilisation des Locks de Java 5 est certes plus complet que le mot-clé synchronized, mais pas dans les examples que tu présentes...
Si tu veux faire un bout de code synchronisé, tu peux très bien faire un synchronized(unMutex) { ... code en mutex }, et ça revient exactement au même que lock.lock() / lock.unlock().

Là où ça a un intérêt, c'est quand tu as besoin de plusieurs variables conditions, et ça évite le cas suivant:

Code:

---

1 2 3 4 5

synchronized(a) { synchronized(b) { b.wait(); //ne relâche pas le verrou de a } }

---

Je sais mes exemples ne sont pas des exemples dans lesquels les locks sont un avantage flagrant mais lesdits exemples sont un peu compliqués et ne sont pas forcément clairs ni en rapports directs avec la question posée;)
Donc ... voilà lol.

Perso je les utilise avec des objets de condition.