Discussion :

[Larger]

Bonjour,


J'ai vu dans la documentation à quoi correspondent ces deux méthodes.
Seulement dans un cadre un poil plus poussé, je me pose certaines questions :

Dans mon thread je lance un runnable par l'intermédiaire d'un InvokeAndWait(). Si je lance dans mon runnable un nouveau runnable en InvokeLater(), que va-t-il se passer ?

Autrement dit, le thread va-t-il attendre que le runnable secondaire se termine ?

Et en inversant les deux méthodes ?



Merci d'avance pour votre attention.

[®om]

Si dans un runnable passé en paramètre d'un invokeAndWait tu fais un invokeLater d'un second runnable, ce runnable sera exécuté APRÈS la fin de ton 1er.

Si dans un runnable passé en paramètre d'un invokeLater tu fais un invokeAndWait, tu as une exception au runtime.

[Larger]

Ah ben c'est clair net et précis, merci

[adiGuba]

Salut,


Pour plus de détail : l'EDT correspond en fait à une pile de tâche à exécuter. Il s'agit d'une pile FIFO (c'est à dire que les tâches sont exécutées dans l'ordre où elles arrivent).

Ces tâches peuvent correspondre à des appel à invokeLater() ou invokeAndWait() ou à des traitements propre à l'EDT (mise à jour de l'affichage, gestion des événements...).


Lorsque tu fais un invokeLater(), tu rajoutes simplement une tâche en fin de liste. Tu peux donc appeler cette méthode depuis n'importe où y compris depuis une tâche de l'EDT, et le traitement sera effectué plus tard.
Il est d'ailleurs parfois utile d'utiliser un invokeLater() depuis l'EDT : par exemple lorsqu'on modifie un composant, les composants parents (comme un JScrollPane) sont avertis "plus tard" de cette modif, et utiliser invokeLater() permet de modifier le parent une fois que sont état est bien "à jour".


invokeAndWait() fonctionne un peu différemment. En fait elle exécute un invokeLater() et passe donc le traitement en fin de pile. Mais elle utilise par dessus un mécanisme de synchronisation (wait/notify) afin de déterminer le moment où le traitement sera terminé, et bloque le thread courant en attendant. De ce fait invokeAndWait() ne peut pas être appeller depuis l'EDT car cela entrainerai un dead-lock puisque le thread s'attendrai lui-même (par sécurité cela provoque une exception).


a++

[Larger]

Ok ! Merci pour ces précisions je crois que ça commence à rentrer.


En fait je pourrais peut-être expliquer ce qui me pousse à poser cette question.
Mon graphique est géré dans le thread principal et mis à jour par l'intermédiaire d'Observable/Observer.
Je lance un thread qui effectue des traitements. Celui-ci appelle notifyObserver() dans un runnable lancé par un InvokeAndWait().

Si je ne me trompe pas, le runnable se termine sans que tous les update() appelés par notifyObserver() se soient terminés non ?
Ben justement c'est ce que je voudrais bien faire


PS : j'espère ne pas trop être embrouillant