Attente bloquante : comment faire?

Version imprimable

Salut,

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

Code:

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:

1
2
showSplashScreenBloquant();
actionsApresLeSplashOuSiLeChargementDuSplashAPlante();

23/08/2006, 20h29
the-gtm

Fais une recherche sur "SwingWorker", ça devrait te donner des idées ;)
23/08/2006, 20h34
®om

Citation:

Envoyé par the-gtm

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

Salut,

Tu peux utiliser les Semaphore de Java 5.0 :

Code:

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:

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

23/08/2006, 20h58
®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?

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:

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:

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

23/08/2006, 22h15
the-gtm

tu as essayé pack() sur la frame ?
23/08/2006, 22h21
®om

Citation:

Envoyé par the-gtm

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...
23/08/2006, 22h40
®om

En fait ça marche... Sauf si je lance l'appli à partir de eclipse :)
En .jar direct ça marche :)
23/08/2006, 22h51
adiGuba

Citation:

Envoyé par ®om

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 :mrgreen:

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++
23/08/2006, 23h09
®om

Citation:

Envoyé par ®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?
23/08/2006, 23h44
®om

Citation:

Envoyé par ®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 :(
22/09/2006, 20h09
®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...
25/09/2006, 10h37
Pollux

Citation:

Envoyé par ®om

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??

Citation:

Envoyé par Pollux

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

Citation:

Envoyé par ®om

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:

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 !