Discussion :

[dark0502]

Salut à tous,

je suis en train de concevoir une application et j'ai un petit problème. Je possède un bouton sur mon interface graphique pour pouvoir interrompre le jeu. Quand je clique dessus, il atterit dans la méthode suivante pour mettre en pause mon Timer(de la classe swing.Timer). Je remarque que mon programme reste dans l'exécution de timer.wait() et n'exécute jamais stopwatch.stop()

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void pauseGame() {
 
		if (!avatarToPlay.isAI()) {
			interrupted = true;
 
			synchronized (timer) {
				try {
					timer.wait();
					stopWatch.stop();
				} catch (InterruptedException e) {
				}
			}
		}
	}

merci

[Aldian]

Salut

le code que tu donnes n'est pas suffisant, c'est dur de deviner de quels types sont tes objets pas vrai?

Moi je n'ai pas l'habitude des timers. Cependant, si la méthode wait que tu utilises est celle de la classe Object, la javadoc est très claire:

Après l'appel de la méthode wait, l'objet va dormir jusqu'à ce que la méthode notify ou notifyall soit appelée. Si tu ne l'appelles pas, l'objet dormira indéfinimént

[dark0502]

timer est en fait une instance de la classe Timer du package de swing.
Quand je fais appel à la méthode ci-dessous, il affiche bien 'avant appel' mais pas 'apres appel'. Pourtant, pas d'erreurs apparait.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public void pauseGame() {
 
       synchronized (timer) {
		try {
                        System.out.println("avant appel");
			timer.wait();
			System.out.println("apres appel');
		} catch (InterruptedException e) {
		}
	}
}

[tchize_]

on peux voir le code qui fait timer.notify() ?

[dark0502]

Code :

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

1
2
3
4
5
6
7
8
public void resumeGame() {
	interrupted = false;
 
	synchronized (timer) {
		timer.notify();
		stopWatch.start();
	}
}

[tchize_]

Ces méthodes sont appelées comment? Dans quels threads? Pourquoi voulez vous arrêter le thread courant (appel wait()) plutot que de juste arrêter le timer ( stop )?

[kolodz]

Il me semble qu'il y a un problème de logique dans l'utilisation du mot-clé "synchronized" Java.

En effet, celui-ci est utilisé pour l'implémentation de section critique et l'exclusion mutuelle.
J'en prend pour fait cette article :
http://rom.developpez.com/java-synchronisation/#LII-A

Or ici, le la fonction "wait()" bloque la section critique associé à la variable "timer".

Code :

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

1
2
3
4
5
6
7
synchronized (timer) {
try {
	timer.wait();
	stopWatch.stop();
} catch (InterruptedException e) {
}
}

Ce qui implique que le code suivant ne peut d’exécuter temps qu'on ne sort pas du code précédent :

Code :

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

1
2
3
4
synchronized (timer) {
	timer.notify();
	stopWatch.start();
}

Or il faut un timer.notify() pour sortir du premier synchronized.

Il y a selon moi un problème de conception.

Si tu veux vraiment avoir un jeu qui se place en pause utilise une variable boolean "isPlaying" que tu vérifie à chaque pas de ton jeu.
Si celle-ci est à false tu ne modifie pas l'état du jeu et tu affiche ce qu'il faut.

EDIT :
@tchize_ : Merci pour l'information, je n'étais en effet pas au courant pour la libération du synchronized sur le wait.

Note that the wait method, as it places the current thread into the wait set for this object, unlocks only this object; any other objects on which the current thread may be synchronized remain locked while the thread waits.

En effet cela fonction, le test suivant :

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
public class Test implements Runnable{
	public static  String tit = "dd";
	public static void main(String[] args) {
		new Thread(new Test()).start();
		new Thread(new TestNotify()).start();
	}
	@Override
	public void run() {
		synchronized (tit) {
			try {
				System.out.println("start wait");
				tit.wait();
				System.out.println("Stop wait");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
class TestNotify implements Runnable {
 
	@Override
	public void run() {
		synchronized (Test.tit) {
			System.out.println("Start notify");
			Test.tit.notify();
			System.out.println("End notify");		
		}
	}
}

donne le résulat :

start wait
Start notify
End notify
Stop wait

ou

Start notify
End notify
start wait

Cordialement,
Patrick Kolodziejczyk.

[tchize_]

@kolodz, vous devriez lire la doc de wait(), elle mentionne explicitement qu'il faut faire ce synchronized et que wait va le libérer au moment de s'endormir pour le récupérer au moment de son réveil.

Il y a effectivement je pense erreur de conception, mais elle ne se situe pas là