Discussion :

[clmin]

Bonjour,
j'ai des problèmes avec l'ordre d’exécution de mes tâches.
Je m'explique:
1/ J'ai initialement créer une classe Annotation afin de renvoyer diverses info depuis un fichier:

Code :

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

1
2
3
4
5
6
7
8
9
10
public class Annotion {
	public List<Variant> main(File file) {
		return annote(file);
	}
	private List<Variant> annote(File file){
		List<Variant> listVar = new ArrayList<Variant>();
		//ma fonction ici...
		return listVar;
	}
}

2/ Jusque là pas de problème. J'ai voulu ajouter une barre de progression, et ai donc mis la fonction dans une tâche:

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
public class Annotion {
	private List<Variant> listVar = new ArrayList<Variant>();
 
	public List<Variant> main(File file) {
		//Tâche
		Task task = new Task<Void>() {
		    @Override public Void call() {
		    	listVar = annote(file);
		        return null;
		    }
		};
		//Indicateur de progression
		ProgressIndicator bar = new ProgressIndicator();
		bar.progressProperty().bind(task.progressProperty());
		Group root = new Group();
		Scene scene = new Scene(root, 300, 250);
        	Stage stage = new Stage();
        	stage.setScene(scene);
        	stage.setTitle("Progress Controls");
        	scene.setRoot(bar);
        	stage.show();
	        //Début de la tâche
		Thread t = new Thread(task);
		t.start();
		//Retour de la liste mise à jour
		return listVar;
	}
	private List<Variant> annote(File file){
		List<Variant> listVar = new ArrayList<Variant>();
		//ma fonction ici...
		return listVar;
	}
}

J'ai alors rencontré un problème: la tâche commence, avec une belle barre de progression, puis retourne la liste... alors que la tâche n'est pas finie! Et donc la liste loin d'être complête!
3/ J'ai essayé de resoudre ça en attendant que la tâche se termine:

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
36
37
38
public class Annotion {
	private List<Variant> listVar = new ArrayList<Variant>();
	private Boolean running;
 
	public List<Variant> main(File file) {
		//Tâche
		Task task = new Task<Void>() {
		    @Override public Void call() {
		    	listVar = annote(file);
		        return null;
		    }
		};
		//Indicateur de progression
		ProgressIndicator bar = new ProgressIndicator();
		bar.progressProperty().bind(task.progressProperty());
		Group root = new Group();
        	Scene scene = new Scene(root, 300, 250);
        	Stage stage = new Stage();
        	stage.setScene(scene);
        	stage.setTitle("Progress Controls");
        	scene.setRoot(bar);
        	stage.show();
        	//Début de la tâche
		running = true;
		Thread t = new Thread(task);
		t.start();
		//Attendre la fin de la tâche
		while (running){}
		//Retour de la liste mise à jour
		return listVar;
	}
	private List<Variant> annote(File file){
		List<Variant> listVar = new ArrayList<Variant>();
		//ma fonction ici...
		running = false;
		return listVar;
	}
}

Nouveau problème: la barre de progression est vide... jusqu'à ce que la tâche finnisse! J'ai fini par comprendre que la barre de progression ne commence à "tourner" que lorsque toute la méthode est exécutée...

A ce point, je suis à cours d'idée qur comment faire. Quelqu'un aurait une solution?
Merci!

[bouye]

Oh cette gestion des threads moche....

Vu que tu crée une scene dans ta méthode main() je suppose que ce code est appelé sur le JavaFX Application Thread ? Ben alors c'est très simple : lorsque tu appelles while (running){}, tu bloques toute ton UI tant que le thread n'est pas terminé.

Qu'est ce qui t’empêche d'utiliser un Service (de JavaFX) ou un executor (de l'API standard) pour lancer ta tache ????? Ta méthode main() doit-elle être absolument bloquante ? Retourner une ObservableList<Variant> plutôt q'une List<Variant> ne serait-il pas préférable ?

-> Tutoriel sur l'exécution d'une tâche de fond en JavaFX

[clmin]

Merci pour ta réponse.
- ObservableList<Variant> rendrait des problèmes plus tard, c'est pourquoi je ne l'ai pas utilisé. Cela peut être converti cependant, s'il y a une bonne raison pour ça (autre que "ce serait plus propre")?
- La main() doit absolument être la seule chose qui tourne (fonction annote() + barre de progression), et tout le reste en attente que annote() renvoie le résultat.
- Je ne connaissait pas les services de JavaFX, mais ok...

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
36
37
38
39
40
public class Annotion {
	private List<Variant> listVar = new ArrayList<Variant>();
 
	public List<Variant> main(File file) {
		//Service
		Service<List<Variant>> annotationService = new Service<List<Variant>>(){
			@Override
			protected Task<List<Variant>> createTask() {
				return new Task<List<Variant>>(){
					@Override
					protected List<Variant> call() throws Exception {
						List<Variant> listVar = annote(file);
						return listVar;
					}
				};
			}
		};
		//Indicateur de progression
		ProgressIndicator bar = new ProgressIndicator();
		bar.progressProperty().bind(annotationService.progressProperty());
		Group root = new Group();
        Scene scene = new Scene(root, 300, 250);
        Stage stage = new Stage();
        stage.setScene(scene);
        stage.setTitle("Progress Controls");
        scene.setRoot(bar);
        stage.show();
 
		annotationService.start();
		List<Variant> listVar = annotationService.getValue();
 
		//Retour de la liste mise à jour
		return listVar;
	}
	private List<Variant> annote(File file){
		List<Variant> listVar = new ArrayList<Variant>();
		//ma fonction ici...
		return listVar;
	}
}

... ce qui ne change rien au problème. La classe renvoie une liste vide avant que annote() ait le temps de s’exécuter, et au moment où annote() a effectivement créer la list dont j'ai besoin, elle n'est plus renvoyée car le main de la classe Annotion est terminé depuis longtemps.

[bouye]

Justement non : si ton code s’exécute dans le JavaFX Application Thread (ce que tu peux vérifier par la méthode Platform.isFxApplicationThread()), alors ta méthode ne doit pas être bloquante. Et puis c'est tout.
Donc tu dois revoir l'architecture de ton truc ; et si tu as besoin d'une méthode bloquante, elle doit s’exécuter dans un autre thread.

[clmin]

Je ne comprend pas à quoi tu dis "Justement non ".
L'un dans l'autre, je m'en fiche si la méthode a la propriété bloquante ou non, je veux juste que RIEN ne soit fait (ou faisable) jusqu'à ce que la classe Annotion renvoie la liste à ma méthode principale.

[bouye]

Tu ne dois pas bloquer l'exécution du JavaFX Application Thread de JavaFX tout comme tu ne dois pas bloquer l'EDT (Event Distatch Thread) de AWT / Swing. C'est le thread événementiel de l'UI et le bloquer signifier bloquer, geler, voir faire planter ton interface graphique (d'où le fait que rien ne s'affiche de la progression d'ailleurs).

Tu veux exécuter un truc lorsque la liste est complétée ? Tu ajoute un action lorsque ton service est dans l'état suceeded, tu récupère la liste retournée par le service et tu la refourgue au contrôle qui doit l'utiliser. Entre les deux (le moment ou tu lance le service et le moment ou il retourne) tu met ce qu'il faut pour que l'utilisateur ne puisse pas utiliser l'UI (désactiver toute saisie, mettre un écran d'attente, cacher les contrôles, etc.). C'est le B A BA de la programmation événementielle en UI.

[clmin]

Ok, j'ai compris et ça marche bien!
Merci beaucoup
Juste une dernière chose: puisque la tâche ne bloque plus le programme, j'ai forcé le focus sur la bar de progression.