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()...

[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++