FAQ JavaFXConsultez toutes les FAQ

JavaFX utilise trois threads principaux :

• le JavaFX Application Thread - il s'agit du thread événementiel de l'interface graphique, du SceneGraph et de la scène. Les nœuds graphiques qui sont attachés à une scène ne peuvent être manipulés que dans ce thread. Ce thread est celui dans lequel vous travaillerez et dans lequel votre code s’exécutera la plupart du temps ;
• le thread de rendu Prism - il s'agit du thread qui est utilisé pour effectuer le moteur de rendu Prism qui se charge du rendu à l’écran. Ce thread n'est normalement pas directement accessible au programmeur ;
• le thread média - ce thread qui tourne en tâche de fond et est utilisé pour synchroniser l’affichage en mettant à jour, par exemple, les intervalles (étapes intermédiaires) lors d'animations et de transitions. Ce thread n'est normalement pas directement accessible au programmeur.
  

Il peut arriver que vous ayez besoin d'effectuer une tâche de longue durée (traitement long, lecture/écriture de fichier, vous connecter à une base de données, à un web service, etc.). JavaFX met à disposition, dans le package javafx.concurrent, une API de concurrence qui permet de gérer de telles tâches sans pour autant bloquer le JavaFX Application Thread.

Pour utiliser cette API de concurrence, vous allez devoir utiliser des objets d'un des trois types suivants :

• Service<V> - qui est une classe service à manipuler depuis votre UI, dans le JavaFX Application Thread. Une instance de la classe Service peut être réutilisée plusieurs fois.
• ScheduledService<V> - qui est une classe service à manipuler depuis votre UI, dans le JavaFX Application Thread. Ce genre de service s’exécute de manière cyclique à intervalles réguliers - JDK8 ou ultérieur.
• Task<V> - qui est la classe qui se chargera d’exécuter la tâche de longue durée. Elle s’exécutera dans son propre thread, sans interférer ni bloquer le JavaFX Application Thread. Une instance de la classe Task ne peut être utilisée qu'une seule et unique fois. La tâche est créée par le service.
  

Pour créer une tâche de fond, depuis notre IU (par exemple en réponse à un clic sur un bouton), nous allons créer une instance de la classe abstraite Service<V> avec le type de retour approprié. Nous allons ensuite surcharger la méthode createTask() de manière à initialiser une instance de la classe abstraite Task<V>. Dans cette tâche, nous allons surcharger la méthode call() pour effectuer le traitement de longue durée. Le résultat du traitement sera retourné en fin de méthode.

Par exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
final Service<Integer> service = new Service<Integer>() { 
  
    @Override 
    protected Task<Integer> createTask() { 
        return new Task<Integer>() { 
  
            @Override 
            protected Integer call() throws Exception { 
                int result = 0; 
                // Faire le traitement ici. 
                return result; 
            }                             
        }; 
    }                     
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
final Service<Void> service = new Service<Void>() { 
  
    @Override 
    protected Task<Void> createTask() { 
        return new Task<Void>() { 
  
            @Override 
            protected Void call() throws Exception { 
                // Faire le traitement ici. 
                return null; 
            }                             
        }; 
    }                     
};

Il est possible de surveiller les changements d’état d'un service en plaçant un écouteur de type InvalidationListener ou ChangeListener sur sa propriété state.



Cette propriété, de type Worker.State, peut avoir les états suivants :

• READY - le service est prêt à être lancé : il vient d’être créé ou il a été réinitialisé ;
• SCHEDULED - le service a été lancé, mais n'a pas encore démarré ;
• RUNNING - le service a démarré, le traitement est en cours ;
• CANCELLED - le service a été annulé ;
• FAILED - le service a échoué (ex. : une exception a été lancée au cours du traitement) ;
• SUCCEEDED - le service s'est terminé sans erreur. Il est possible d'accéder au résultat du traitement ou de relancer le service.
  

1
2
3
4
5
service.stateProperty().addListener(observable -> { 
    switch (service.getState()) { 
        // Traiter les différents cas ici. 
    } 
});

• setOnReady() - le service est passé dans l’état READY ;
• setOnScheduled() - le service est passé dans l’état SCHEDULED ;
• setOnRunning() - le service est passé dans l’état RUNNING ;
• setOnCancelled() - le service est passé dans l’état CANCELLED ;
• setOnFailed() - le service est passé dans l’état FAILED ;
• setOnSucceeded() - le service est passé dans l’état SUCCEEDED.
  

1
2
3
4
5
6
7
service.setOnSucceeded(new EventHandler<WorkerStateEvent>() { 
  
    @Override 
    public void handle(WorkerStateEvent workerStateEvent) { 
        System.out.println("Traitement terminé !"); 
    } 
});

service.setOnSucceeded(workerStateEvent -> System.out.println("Traitement terminé !"));

Il est possible de surveiller les changements d’état d'une tâche en plaçant un écouteur de type InvalidationListener ou ChangeListener sur sa propriété state.



Cette propriété, de type Worker.State, peut avoir les états suivants :

• READY - la tâche est prête à être lancée : elle vient d’être créée ;
• SCHEDULED - la tâche a été lancée, mais n'a pas encore démarré ;
• RUNNING - la tâche a démarré, le traitement est en cours ;
• CANCELLED - la tâche a été annulée ;
• FAILED - la tâche a échoué (ex. : une exception a été lancée au cours du traitement) ;
• SUCCEEDED - la tâche s'est terminée sans erreur. Il est possible d'accéder au résultat du traitement.
  

1
2
3
4
5
task.stateProperty().addListener(observable -> { 
    switch (task.getState()) { 
        // Traiter les différents cas ici. 
    } 
});

• setOnScheduled() - le service est passé dans l’état SCHEDULED ;
• setOnRunning() - le service est passé dans l’état RUNNING ;
• setOnCancelled() - le service est passé dans l’état CANCELLED ;
• setOnFailed() - le service est passé dans l’état FAILED ;
• setOnSucceeded() - le service est passé dans l’état SUCCEEDED.
  

1
2
3
4
5
6
7
task.setOnSucceeded(new EventHandler<WorkerStateEvent>() { 
  
    @Override 
    public void handle(WorkerStateEvent workerStateEvent) { 
        System.out.println("Traitement terminé !"); 
    } 
});

task.setOnSucceeded(workerStateEvent -> System.out.println("Traitement terminé !"));

Pour démarrer un service, il suffit d'invoquer la méthode start() de ce service.

Par exemple :

service.start();

Pour annuler un service, il suffit d'invoquer la méthode cancel() de ce service.

Par exemple :

service.cancel();

Pour savoir si une tâche a été annulée, le programmeur doit régulièrement tester la valeur de retour de la méthode isCancelled() de la tâche durant son traitement. Si cette méthode retourne true, c'est que la tâche a été annulée et que le traitement doit être interrompu.

Par exemple, le code suivant est une tâche qui teste si un nombre donné est premier :

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
public class PrimeTestTask extends Task<Boolean> { 
  
    private final int value; 
  
    public PrimeTestTask(final int value) { 
        this.value = Math.abs(value); 
    } 
  
    @Override 
    protected Boolean call() throws Exception { 
        Boolean result = Boolean.TRUE; 
        if (value == 0 || value == 1 || (value > 2 && value % 2 == 0)) { 
            result = Boolean.FALSE; 
        } else if (value > 2) { 
            for (int test = 3; test * test < value; test += 2) { 
                // Le traitement a été annulé. 
                if (isCancelled()) { 
                    return null; 
                } 
                if (value % test == 0) { 
                    result = Boolean.FALSE; 
                    break; 
                } 
            } 
        } 
        return result; 
    } 
}

Pour pouvoir redémarrer un service, il faut que ce dernier soit à nouveau dans un état READY. Il est possible de réinitialiser la valeur de cet état en appelant la méthode reset() du service.



Par exemple :

service.reset();

service.restart();

1
2
3
service.cancel(); 
service.reset(); 
service.start();

Il est possible d'envoyer des notifications durant un traitement long. La classe Task<V> dispose de quatre méthodes destinées à cet effet, et qui peuvent être invoquées directement depuis le code s’exécutant dans la méthode call() de la tâche :

• updateMessage() - permet de faire remonter un message textuel ;
• updateProgress() - permet d'indiquer l’état d'avancement du traitement. Cette méthode prend deux valeurs en paramètres, l'avancement actuel et l'avancement total. Un avancement négatif ou invalide (infinité ou NaN) résultera en une valeur de progression indéterminée ;
• updateTitle() - permet de modifier l’intitulé du traitement ;
• updateValue() - permet de modifier la valeur de retour de la tâche pour spécifier une valeur intermédiaire - JDK8 ou ultérieur.
  

• message - le dernier message posté.
• progress - le dernier état d'avancement du traitement. Cette valeur est initialement à 0. Une valeur de 1 indique normalement que le traitement est terminé. Une valeur de -1 indique que l'avancement est indéterminé.
• title - le dernier intitulé du traitement.
• value - la dernière valeur du traitement. Cette propriété sera également affectée à la valeur de retour de la tâche à la fin du traitement.
  

1
2
3
titleLabel.textProperty().bind(service.titleProperty()); 
progressLabel.textProperty().bind(service.messageProperty()); 
progressBar.progressProperty().bind(service.progressProperty());

Pour récupérer le résultat final d'un service, il suffit de récupérer la valeur de sa propriété en lecture seule value lorsque le service est dans l’état SUCCEEDED.

Par exemple :

1
2
3
4
service.setOnSucceeded(workerStateEvent -> { 
    final V result = service.getValue(); 
    System.out.printf("Traitement terminé %s !", result).println(); 
});

Pour connaitre les causes de l’échec d'un service, il faut récupérer la valeur de sa propriété en lecture seule exception lorsque le service est dans l’état FAILED. Cette propriété contient une valeur de type java.lang.Throwable.

Par exemple :

1
2
3
4
service.setOnFailed(workerStateEvent -> { 
     System.err.println("Échec du service !"); 
     service.getException().printStackTrace(); 
});

Depuis le JDK 8, pour créer une tâche de fond répétable, depuis notre IU (par exemple en réponse à un clic sur un bouton), nous allons créer une instance de la classe abstraite ScheduledService<V> avec le type de retour approprié. Nous allons ensuite surcharger la méthode createTask() de manière à initialiser une instance de la classe abstraite Task<V>. Dans cette tâche, nous allons surcharger la méthode call() pour effectuer le traitement de longue durée. Le résultat du traitement sera retourné en fin de méthode.

Par exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
final ScheduledService<Integer> service = new ScheduledService<Integer>() { 
  
    @Override 
    protected Task<Integer> createTask() { 
        return new Task<Integer>() { 
  
            @Override 
            protected Integer call() throws Exception { 
                int result = 0; 
                // Faire le traitement ici. 
                return result; 
            }                             
        }; 
    }                     
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
final ScheduledService<Void> service = new ScheduledService<Void>() { 
  
    @Override 
    protected Task<Void> createTask() { 
        return new Task<Void>() { 
  
            @Override 
            protected Void call() throws Exception { 
                // Faire le traitement ici. 
                return null; 
            }                             
        }; 
    }                     
};

Pour différer le lancement d'une tâche de fond répétable, vous devez spécifier une valeur de type javafx.util.Duration dans la propriété delay de votre instance de la classe ScheduledService<V>.

Par exemple :

1
2
service.setDelay(Duration.seconds(5)); 
service.start();

Pour autoriser une tâche de fond répétable à se relancer en cas d’échec, vous devez modifier la valeur de la propriété restartOnFailure de l'instance de la classe ScheduledService<V> et lui donner la valeur true.

Par exemple :

service.setRestartOnFailure(true);

Pour limiter le nombre de répétitions d'une tâche de fond répétable en cas d’échec, vous devez modifier la valeur de sa propriété maxFailureCount.

Par exemple :

service.setMaxFailureCount(100);

Pour connaitre le nombre d’échecs d'une tâche de fond répétable, vous pouvez interroger sa propriété en lecture seule currentFailureCount. Cette propriété contient le nombre d’échecs du service depuis son lancement initial. Ce nombre sera réinitialisé à zéro si le service est manuellement redémarré.

Par exemple :

final int failureNumber = service.getCurrentFailureCount();

Pour spécifier la période d'une tâche de fond répétable, vous devez spécifier une valeur de type javafx.util.Duration dans la propriété period de votre instance de la classe ScheduledService<V>. Il s'agit de la période de temps qui s’écoule entre deux moments durant lesquels le service passe dans un état RUNNING lors d'une exécution couronnée de succès.

service.setPeriod(Duration.seconds(1));

1
2
3
4
5
6
service.setBackoffStrategy(new Callback<ScheduledService<?>, Duration>() { 
  
    public Duration call(ScheduledService<?> service) { 
        return Duration.seconds(service.getCurrentFailureCount() * 5); 
    } 
});

service.setBackoffStrategy(service -> Duration.seconds(service.getCurrentFailureCount() * 5));

service.setMaximumCumulativePeriod(Duration.minutes(10));

Lorsqu'une tâche de fond répétable se relance, sa propriété value est réinitialisée avec la valeur null. Cependant la propriété en lecture seule lastValue conserve le résultat de la dernière bonne exécution du service.

Par exemple :

final Integer lastResult = service.getLastValue();