Discussion :

[Jcangel]

Bonjour/Bonsoir tout le monde.

Mon titre est loin d'être le meilleur mais mon problèmes est plutôt complexe est difficile a expliquer

Je m'explique je suis en train de développer un jeu (de société) en java (pour un projet d'étude). Je dois également créer un joueur contrôler par l'ordinateur (une "IA").
C'est justement pour intégrer cette IA que j'ai de gros problèmes.
Pour donné plus de détaille je me suis basé sur le pattern MVC pour la réalisation de mon code.
Je ne sais déjà pas où je doit mettre cette IA par rapport au Pattern MVC. C'est une sorte de vue qui utilise un contrôleur ? cela doit être géré directement dans le Modèle ? (je pense pas que ça soit dans le contrôleur ?)

Bref c'est plus du détail. je suis parti sur l'idée de considéré l'IA comme une vue.
Mon problème principale c'est que je ne veux pas que l'interface graphique (swing) soit gelé/freeze pendant que l'IA est en train de calculer son coup (qui peut-être long) et que l'utilisateur puisse continué a faire toute sorte d'action (annuler son coup par exemple)

Je veux donc que le calcule du coup ne bloque pas l'interface et que si l'utilisateur fait une action qui modifie l’état du jeu (annuler un coup par exemple) arrêter le calcule en cours (car ça ne sert plus a rien de continué les donnés auront changé et le résultat serra donc faux et inutilisable).

Je pensais donc faire avec une Thread qui effectue le calcule et qui appelle le contrôleur une fois la solution trouvé. et je voulais arrêter ce thread lorsque l'etat du jeu est modifier. J'ai (normalement) gérer tout les problèmes de synchronisation. Ma solution semble fonctionné.
Par contre je ne suis clairement pas satisfait du résultat qui est je trouve vraiment pas propre et qui en plus utilise une méthode depreciated (thread.stop() ) et par dessus tout je crée un nouveau thread a chaque fois que l'ia doit joué.

J'ai beau tourner le problèmes dans tout les sens depuis plusieurs jours je n'arrive vraiment pas a trouver de bonne solution je fais donc appelle a vous en espérant que quelqu'un pourra m'aider

Je vous donne également le code en question :

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
31
32
33
34
35
 
public class Ordinateur implements Observer {
 
    private Controleur c;
    private Moteur m;
    private Thread t;
    private ThreadOrdinateur ia;
 
	public Ordinateur(Controleur c, Moteur m) {
		super();
		this.c = c;
		this.m = m;
		init();
	}
 
	private void init() {
		ia = new ThreadOrdinateur(c, m);
		t = new Thread(ia);
	}
 
	public void update(Observable o, Object arg) {
		if (ia.modife == false) {
			t.stop();
			try {
				t.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		ia = new ThreadOrdinateur(c, m);
                t = new Thread(ia);
		t.start();
	}
 
}

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 ThreadOrdinateur implements Runnable {
 
    private Controleur c;
    private Moteur m;
    boolean modife;
 
    public ThreadOrdinateur(Controleur c, Moteur m) {
    	this.m = m;
    	this.c = c;
        modife = false;
    }
 
    public void run() {
    	modife = false;
        Coup coup = calculeDuCoup();
    	modife = true;
        c.joueurCoupIa(coup); //(Si j'arrête le thread pendant la modification des données ça va créer des incohérence ils me sembles ?)
        modife = false;
    }
}

Merci de m'avoir lu et Merci d'avance de vos réponse

[thelvin]

interrupt() à la place de stop().

Le thread de l'IA doit appeler de temps en temps isInterrupted() pour déterminer s'il ne devrait pas s'arrêter.
Si oui, arrête-le comme ça t'arrange pour revenir dans un état de départ, et le thread devient ainsi réutilisable pour le prochain calcul. Si non, continuer le calcul.

Ceci étant dit, si interrupt() n'existait pas, il suffirait d'une variable volatile boolean shouldStop et de la vérifier de temps en temps.

Et ton titre est très bien, "calcul" ne prend pas de "e" mais à part ça je ne vois pas le problème.

[Jcangel]

Merci de ton aide et désolé pour les fautes d'orthographes

En faite mon gros problèmes c'est que la fonction calculeDuCoup(); prend beaucoup de temps et que je ne peux pas facilement la modifié (donc interrupt() m'aide pas vraiment).
En gros c'est elle que je veux pouvoir lancé en parallèle récupérer le résultat (et une fois que j'ai le résultat faire des modification en conséquence) je veux également pouvoir l’arrêter (n'importe ou car ça ne modifie rien)

[Dantidot]

Salut,
Dans ce cas la cette fonction doit être un thread ou lancé en thread et si tu veux l'arrêter tu stop ton thread ....

[wax78]

Tu ne dois surtout pas utiliser stop() qui est déprécié.

De plus, l'interrompre n'interrompra par le thread forcement. Surtout si le thread exécute une fonction bloquante non interruptible dans le thread.

Sinon, je pense qu'il va falloir aller trifouiller dans le code de la "dite méthode" pour tenter de mettre une condition d'arrêt si c'est possible.

[thelvin]

En faite mon gros problèmes c'est que la fonction calculeDuCoup(); prend beaucoup de temps et que je ne peux pas facilement la modifié (donc interrupt() m'aide pas vraiment).

Dans ce cas laisse tomber, 'y a pas de solution propre. Quand on ne peut pas modifier on a pas de solution. Le mieux que tu pourrais faire c'est de lancer un nouveau programme juste pour exécuter cette méthode, et de l'arrêter si tu veux. Pas de risque de mémoire corrompue ou d'état incohérent, mais :
- C'est monstrueusement chiant
- Non seulement tu réutilises pas le thread, mais tu crées carrément un nouveau processus.

[hwoarang]

Tu as aussi l'option de laisser le thread finir tranquillement son calcul mais de ne pas attendre qu'il ait fini. Lorsqu'il aura terminé son traitement, ne pas utiliser le résultat. C'est moche mais sans modifier le code, il n'y a pas de méthode propre...