Discussion :

[Linquisiteur]

Bonjour, j'ai implémenter un thread qui notifie une interface graphique avec le pattern observer
Mon problème est que l'application freeze entièrement dès la 1er seconde à cause d'un bug.

Je pense que le problème vient du sleep mais je ne comprend pas comment faire autrement

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
package DATA.WORKTILE;
import DATA.OBSERVER.Observable;
import javafx.application.Platform;
 
 
/**
 * Created by Jordan on 17/11/2015.
 */
public class TimeCounter extends Observable {
 
    static int secondes;
    Thread thread;
    boolean running;
 
 
    public TimeCounter() {
 
    }
 
    public void start(){
 
        secondes = 0;
        running = true;
 
        thread = new Thread(new Runnable() {
            @Override public void run() {
 
                Platform.runLater(new Runnable() {
                    @Override
                    public void run() {
 
                        while(running) {
                            try {
                                secondes++;
                                description = ""+secondes;
                                notifie();
                                System.out.println("pulse... " + secondes);
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                });
            }
        });
 
        thread.start();
    }
 
 
 
    public void stop(){
 
        running = false;
    }
 
}

Merci

[joel.drigo]

Salut,

Platform.runLater() exécute le code dans le thread de JavaFX : comme ce code est une boucle, et qu'un thread ne peut faire qu'une seule chose à la fois, tant que la boucle s'exécute, rien d'autre ne peut s'exécuter dans JavaFX. Ni affichage et ni interaction : donc l'UI est gelée. Par ailleurs, pourquoi lancer un thread pour lancer juste un process dans un autre thread (JavaFX) : si tu fais ta boucle directement dans ce thread, tu verras que ton UI n'est plus bloquée.

[Linquisiteur]

Merci de ta réponse, le problème est que j'ai toujours une exception (javais mi l'autre thread pour ne plus l'avoir)

La classe ne notifie pas l'interface mais fait bien une pulsation par seconde

Code :

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

Exception in thread "Thread-4" java.lang.IllegalStateException: Not on FX application thread; currentThread = Thread-4

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
public void start(){
 
        secondes = 0;
        running = true;
 
        thread = new Thread(new Runnable() {
            @Override public void run() {
 
                while(running) {
                    try {
                        secondes++;
                        description = ""+secondes;
                        notifie();
                        System.out.println("pulse... " + secondes);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
 
            }
        });
 
        thread.start();
    }

[joel.drigo]

C'est dans notifie() que tu obtiens cette erreur ? Parce que tu y fais quelque chose qui doit être fait sur le thread JavaFX probablement : fait uniquement ça par le Platform.runLater() (pas la boucle complète en tout cas).

[Linquisiteur]

J'avais aussi essayer avec seulement les platform.runLater mais dans ce cas le chrono fonctionne mais freeze l'application.

Le problème ne vient pas de mon Observeur car je l'utilise dans d'autre partit du code sans souci

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
public void start(){
 
        secondes = 0;
        running = true;
 
 
        Platform.runLater(new Runnable() {
            @Override
            public void run() {
 
                while(running) {
                    try {
                        secondes++;
                        description = ""+secondes;
                        notifie();
                        System.out.println("pulse... " + secondes);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
 
    }

[win_ubuntu]

essayer çà:

Code :

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

Platform.runLater(() -> notifie());

code de la méthode 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
22
23
24
25
26
public void start(){
 
        secondes = 0;
        running = true;
 
        thread = new Thread(new Runnable() {
            @Override public void run() {
 
                while(running) {
                    try {
                        secondes++;
                        description = ""+secondes;
                        Platform.runLater(() -> notifie());
                        System.out.println("pulse... " + secondes);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
 
            }
        });
 
 
        thread.start();
    }

Je vous invite à consulter :http://stackoverflow.com/questions/3...abase-requests

[bouye]

: FAQ JavaFX / Concurrence

Sans oublier un peu d'auto-pub :

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

Pour le reste, la solution de win_ubuntu est tout a fait correcte si tu comptes rester avec ton propre Thread. Il faudra faire juste attention a ce qu'il n'y ait pas trop de notifications pour éviter d’étrangler le JavaFX Application Thread ; ici avec une notification par seconde, y a pas de soucis.