Discussion :

[Pecose]

Bonjour a tous,
Voila mon problème:

Code :

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

1
2
3
4
5
6
7
public class World {
	public ArrayList<Rectangle> rectangle = new ArrayList<Rectangle>(); 
	public World(){}
	public void Creation(){ rectangle.add(new Rectangle()); }
	public void Update(){ rectangle.get(0).setRect(Panel.getMX(), Panel.getMY(), 100, 100); }
	public void Display(){ Panel.feuille.draw(rectangle.get(0)); }
}

Update est appeler depuis un thread contrairement a Display.
Ce qui pose ce problème évident: Display essaye d'afficher rectangle.get(0) qui en même temps est modifier par Update.

Comment je fait a ce que Display ne puisse accéder qu'aux variables qui ne sont pas en cour de traitement?
Merci de votre aide.

[joel.drigo]

Salut,

Pour empêche 2 threads d'accèder à la même instance au même moment, pour les cas simples, on utilise le mot clef synchronized. Ce mot clef impose qu'un seul thread puisse utiliser la référence synchronisée pendant la durée du bloc synchronisé (on peut mettre synchronized également sur une méthode : la référence synchronisée est alors celle de l'instance de classe qui a la méthode).

Dans ton cas, il s'agit de la référence de Rectangle qu'il y a dans la liste, à la position 0.

Il faudrait donc écrire :

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
public class World {
	public ArrayList<Rectangle> rectangle = new ArrayList<Rectangle>(); 
	public World(){}
	public void Creation(){ rectangle.add(new Rectangle()); }
	public void Update(){ update(rectangle.get(0))}
 
        private void update(Rectangle rectangle) {
              synchronized( rectangle ) {
                   rectangle.setRect(Panel.getMX(), Panel.getMY(), 100, 100); 
              }
         }
 
	public void Display(){ display(rectangle.get(0) }
 
         private void display(Rectangle rectangle) {
               synchronized(rectangle) {
                     Panel.feuille.draw(rectangle);
               }
         }
 
}

Mais attention aux problèmes de deadlock : lorsqu'un thread 1 arrive sur le bloc synchronisé et qu'un autre thread 2 est déjà entré dedans, il va être mis en attente. Mais le thread 1 peut être déjà en train de bloquer une autre référence, qui est synchronisée ailleurs dans un bloc que le thread 2 pourrait exécuter avant de sortir du bloc qui bloque thread 1. Les 2 threads seraient interbloqués indéfiniment.

Ici, on pourrait potentiellement avoir le cas, puisque je vois que update() accède à des propriétés de Panel, qui est la classe qui dessine. Attention, donc, si tu dois également gérer l'accès concurrent aux variables manipulées dans getMX() et getMY().

[Pecose]

Alors merci mais après test ca ne règle pas le problème.
Tu me demande de mettre synchronized sur Update et Display mais c'est sur ArrayList<Rectangle> rectangle qu'il faudrait que je le mette.
Là ce qu'il ce passe c'est que Update, qui est appeler par un Thread, modifie la valeur de rectangle en même temps que Display la récupère pour l'afficher.
Que je mette synchronized sur Display ou Update ca revient au même.
Il faudrait peut être que je mette synchronized sur une méthode qui soit "set" et "get" en même temps... mais comment faire?

[Pecose]

J'ai essayer ca:

Code :

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

1
2
3
4
public synchronized void Controle(boolean x){
		if(x){Update();}
		else{Display();}
	}

Je sais pas si ce que j'ai voulu faire et compréhensible mais en tout cas ca ne marche pas:

Code :

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

Exception in thread "AWT-EventQueue-0" java.lang.IllegalThreadStateException

[adiGuba]

Salut,



Si on utilises la synchronisation, il faut impérativement synchroniser tous les accès à la variables, et via le même lock.

Dans le code de joel.drigo c'est la variable de type Rectangle qui est synchronisé... mais pas l'accès à l'ArrayList<Rectangle> !
Elle doit également l'être si des modif (via Creation()) peuvent intervenir en même temps.


Ensuite il faut bien utiliser le même lock partout où les ressources partagées sont utilisées...
Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
	/*
	 * L'attribut doit être private, pour être sûr que personne n'y accède directement.
         * Il est préférable qu'il soit également final si on l'utilise comme lock.
	 */
	private final ArrayList<Rectangle> rectangle = new ArrayList<Rectangle>(); 
 
	public World(){}
 
	public synchronized void Creation(){ rectangle.add(new Rectangle()); }
	public synchronized void Update(){ rectangle.get(0).setRect(Panel.getMX(), Panel.getMY(), 100, 100); }
	public synchronized void Display(){ Panel.feuille.draw(rectangle.get(0)); }

Mais faut faire gaffe aux dead-locks...

Update est appeler depuis un thread contrairement a Display.

Que veux-tu dire par là exactement ? Une méthode est forcément exécuté dans un thread...


Sinon qu'est-ce que tu utilises pour l'affichage ?
En général on utilise un système mono-thread pour tout ce qui touche à l'affichage (c'est plus simple et moins casse-gueule).


a++

[joel.drigo]

Alors merci mais après test ca ne règle pas le problème.
Tu me demande de mettre synchronized sur Update et Display mais c'est sur ArrayList<Rectangle> rectangle qu'il faudrait que je le mette.

Dans le code posté, tu modifies d'une part une instance de rectangle présent dans une ArrayList et d'autre part la même instance est utilisée pour être dessinée. Il n'y aucun conflit sur l'ArrayList dans ce traitement. Ce serait effectivement le cas si tu ajoutais un rectangle dans un thread, pendant que tu parcours la liste de rectangle de l'autre (et le problème serait même différent).

Ici, le problème est que tu as un thread qui modifie les coordonnées d'un rectangle pendant qu'un autre le modifie : comme il n'est pas possible de tout modifier d'un coup sans que ça prenne un tout petit peu de temps, on va commencer à dessiner un rectangle qui n'est plus le même à la fin du dessin.

D'ailleurs, tu n'aurais pas du tout le problème si tu faisais :

Code :

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

public void Update(){ rectangle.set(0, new Rectangle(Panel.getMX(), Panel.getMY(), 100, 100);) }

Dans ce cas, les deux rectangles seraient des instances différentes et donc pas de conflit. La modification de la case de tableau qui stocke la référence étant atomique, on ne peut lire et écrire de toute manière cette référence en même temps. Il y a forcément un des threads qui fait son action avant l'autre.

Tu es sûr que le problème ne vient pas de getMX() et getMY() plutôt ?

Par contre, dans ce code, tu ne synchronise pas l'instance de Rectangle, mais l'instance de la classe qui contient la méthode controle().

Code :

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

1
2
3
4
public synchronized void Controle(boolean x){
		if(x){Update();}
		else{Display();}
	}

[Pecose]

Tu es sûr que le problème ne vient pas de getMX() et getMY() plutôt ?

Sur! J'ai remplacer par 10,10. Même résulta.

Par contre, dans ce code, tu ne synchronise pas l'instance de Rectangle, mais l'instance de la classe qui contient la méthode controle().

Oui je sais, j'était parti sur autre chose, je sais pas si c'est possible de synchronise l'instance de Rectangle.

Par contre, l'erreur que j'ai envoyer me dit que le souci viens de là:

Code :

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

1
2
3
4
5
6
7
8
9
public class Pattern {
	private static World world = new World();
	private final InternalProcess internalProcess = new InternalProcess();
	public Pattern(){}
	public static World getWorld(){ return world; }
	public void Statement(){ world.Creation(); }
	public void Update(){ internalProcess.start();}//ici
	public void Display(){ world.Controle(false); }
}

ca va là:

Code :

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

1
2
3
4
5
 
public class InternalProcess extends Thread{
	public InternalProcess(){};
	public void run(){ Pattern.getWorld().Controle(true); }
}

[Pecose]

C'est bon j'ai trouver:

Code :

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

public void Update(){ internalProcess = new InternalProcess(); internalProcess.start();}

Je crois que c'est tout, merci de votre aide.