Discussion :

[®om]

Salut,

Je souhaiterais faire une attente bloquante, notamment dans ce cas:

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
private void showXXX() {
    try {
        SwingUtilities.invokeAndWait(new Runnable() {
            public void run() {
                MyJFrame frame = new MyJFrame();
                frame.addWindowListener(new WindowAdapter() {
                    @Override public void windowClosed(WindowEvent e) {
                        arreteLAttenteBloquante();
                    }
                }
            }
        }
    } catch(InvocationTargetException ite) {} catch(InterruptedException ie) {}
    attenteBloquante();
}

Comment coder les méthodes en gras (spécifiquement pour ce cas là)?

En gros c'est pour ensuite faire:

Code :

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

1
2
showSplashScreenBloquant();
actionsApresLeSplashOuSiLeChargementDuSplashAPlante();

[the-gtm]

Fais une recherche sur "SwingWorker", ça devrait te donner des idées

[®om]

Fais une recherche sur "SwingWorker", ça devrait te donner des idées

SwingWorker, ça serait à la place de mon invokeAndWait(...).
Là c'est un autre problème, qui n'a pas de rapport avec l'EDT d'ailleurs...

[adiGuba]

Salut,

Tu peux utiliser les Semaphore de Java 5.0 :

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
        System.out.println("DEBUT");
 
        final Semaphore semaphore = new Semaphore(1);
        semaphore.acquire(); // on demande le sémaphore
 
        // On affiche la JFrame dans l'EDT
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                MyJFrame frame = new MyJFrame();
                frame.addWindowListener(new WindowAdapter() {
                    @Override public void windowClosed(WindowEvent e) {
                        semaphore.release(); // on libère la semaphore
                    }
                });
            }
        });
 
 
        semaphore.acquire(); // on redemande la sémaphore
        // (bloquant car on ne peut en posséder qu'une instance)
 
        System.out.println(" FIN ");

Sinon tu peux tout simplement utiliser le mécanisme de synchronisation de base : les wait()/notify() !

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
        System.out.println("DEBUT");
 
        final Object lock = new Object();
 
        synchronized(lock) {
 
            // On affiche la JFrame dans l'EDT
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    MyJFrame frame = new MyJFrame();
                    frame.addWindowListener(new WindowAdapter() {
                        @Override public void windowClosed(WindowEvent e) {
                            synchronized(lock) {
                                lock.notify(); // on reveille le thread
                            }
                        }
                    });
                }
            });
 
 
            lock.wait(); // on endors le thread courant
            // en attendant un appel à notify() depuis un autre thread
        }
 
        System.out.println(" FIN ");

A noter que dans ces deux cas invokeAndWait() peut tout à fait être ramplacé invokeLater() car on n'a pas besoin d'attendre la fin du traitement (ici la fin du traitement survient lorsque le JFrame est affiché).

a++

[®om]

Nickel, les sémaphores je connaissais en C, je ne savais pas que ça existait (surtout si simplement, par rapport à C) en java...

Sinon pour le wait()/notify(), je n'ai pas essayé, mais vu que tout le bloc est en synchronized(lock), il ne va jamais pouvoir lancer lock.notify(), car il est dans un autre bloc synchronized(lock), si?

[®om]

Je rencontre maintenant un nouveau problème:
Mon splashscreen se lance, le chargement se fait, c'est nickel... Puis mon splashscreen se dispose, et la fenêtre principale se lance... Sauf qu'elle se lance en "minimisé" (dans la barre en bas)...
Un toFront() ou setExtendedState(NORMAL) n'y changent rien

Du code pour aider:

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
    private static void launchSplashScreenAndLoad() {
        final Semaphore semaphore = new Semaphore(1);
 
        try {
            final LoadingSplashScreen splash = LoadingSplashScreen.showSplashScreen(1500);
            // splashOk[0] = true;
            ModuleLoader.getModuleLoader().addLoadingListener(splash);
            /* On demande le sémaphore. */
            semaphore.acquire();
            /* On écoute la fermeture du splashscreen. */
            splash.addWindowListener(new WindowAdapter() {
 
                @Override public void windowClosed(WindowEvent e) {
                    /* Sinon, pour une raison inconnue, l'évènement est déclenché 2x. */
                    splash.removeWindowListener(this);
                    /* On libère le sémaphore. */
                    semaphore.release();
                }
            });
        } catch(SplashScreenException e) {
            Logger.getLogger("MyFreeTV").warning("Le splashscreen n'est pas disponible.");
        } catch(InterruptedException e) {
            Logger.getLogger("MyFreeTV").warning("Chargement du splashscreen interrompu.");
        }
 
        /* Charge les modules, et signale les chargements en cours au splashscreen. */
        ModuleLoader.getModuleLoader().load();
 
        try {
            /* On redemande le sémaphore (bloquant). */
            semaphore.acquire();
        } catch(InterruptedException e) {
            Logger.getLogger("MyFreeTV").warning("Chargement du splashscreen interrompu.");
        }
    }
 
    private static void initialize() {
        launchSplashScreenAndLoad();
 
        mainFrame = new MainFrame(); //donc pas dans l'EDT
    }

Dans MainFrame:

Code :

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

1
2
3
4
5
6
7
8
9
    public MainFrame() {
        super("Titre de la fenêtre");
        ... //Construction de la fenêtre
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                setVisible(true);
            }
        }
    }

Je lance l'appli en appelant initialize()...

[the-gtm]

tu as essayé pack() sur la frame ?

[®om]

tu as essayé pack() sur la frame ?

Non, mais c'est pas qu'elle est petite, elle apparait simplement uniquement ds la barre des tâches, si je clique sur la barre des tâches elle est à la bonne taille...

[®om]

En fait ça marche... Sauf si je lance l'appli à partir de eclipse
En .jar direct ça marche

[adiGuba]

Sinon pour le wait()/notify(), je n'ai pas essayé, mais vu que tout le bloc est en synchronized(lock), il ne va jamais pouvoir lancer lock.notify(), car il est dans un autre bloc synchronized(lock), si?

Si si ca marche

Les méthode wait() et notify() DOIVENT être appellé dans un bloc synchronized() sur l'instance de l'objet sur lequel elle sont appellé.
En fait le wait() "libère" le lock pendant son sommeil, et on ne sors réellement du wait() qu'après qu'il ait récupéré le lock...


a++

[®om]

En fait ça marche... Sauf si je lance l'appli à partir de eclipse
En .jar direct ça marche

Euh, même en .jar direct, en fait ça se lance derrière le navigateur

Qqn a une idée d'où ça peut venir?

[®om]

Euh, même en .jar direct, en fait ça se lance derrière le navigateur

Qqn a une idée d'où ça peut venir?

Ca venait du fait que le splashscreen était en alwaysontop...
Mais je ne vois pas pourquoi...

D'ailleurs, même si je fais un setAlwaysOnTop(false) juste avant le dispose(), ça ne résoud pas le problème, je suis donc obligé d'enlever setAlwaysOnTop(true) au lancement du splash

[®om]

adiGuba, concernant ta solution avec le wait()/notify(), il y a un problème...

Si le notify() est effectué avant le wait() (ce qui est peu probable, mais possible), il y a un deadlock...

[Pollux]

Si le notify() est effectué avant le wait() (ce qui est peu probable, mais possible), il y a un deadlock...

Mais pourquoi est-ce que tu ferais un notify avant un wait??

[adiGuba]

Mais pourquoi est-ce que tu ferais un notify avant un wait??

En général on utilise cela lorsqu'on fait deux tâches en parallèles : on effectue une tâche dans un thread secondaire et une autre dans le thread courant, puis on passe à la suite une fois que les deux tâches sont terminées (cela peut permettre par exemple de "partager" les résultats des deux tâches).

Si le notify() est effectué avant le wait() (ce qui est peu probable, mais possible), il y a un deadlock...

C'est en effet très probable si on ne peut pas être sûr du temps d'exécutions des deux tâches. La meilleure solution est d'utiliser le "double-check" en utilisant une valeur booléenne qui déterminera si la méthode notify a déjà été appellée. Par exemple :

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
public class Main {
 
    private boolean notified = false;
 
    public void waitThis() {
        synchronized(this) {
            while (!this.notified) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.notified = false;
        }
    }
 
    public void notifyThis() {
        synchronized(this) {
            this.notified = true;
            this.notify();
        }
    }
 
    /* Effectue une attente pour simuler un traitement */
    public static void sleeping(int ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) throws Exception {
 
        final Main m = new Main();
        new Thread() {
            public void run() {
 
                sleeping(300);
 
                System.out.println("notifyThis");
                m.notifyThis();
            }
        }.start();
 
        sleeping(1000);
 
        System.out.println("waitThis");
        m.waitThis();
        System.out.println("END");
    }
}

Malgré le fait que le notify() soit appellé bien avant le wait(), on n'a pas de deadlock


a++

PS : toutefois le package concurrent de Java 5.0 permet de se passer de cela grâce à ses classes qui le gère déjà comme les BlockingQueue ou les Semaphore !