Comment créer un fil d'arrière-plan "événementiel" en Java ?

Question

J'aime la simplicité de invokeLater() pour envoyer des unités de travail à l'AWT EDT. Il serait agréable de disposer d'un mécanisme similaire pour envoyer des demandes de travail à un thread d'arrière-plan (tel que SwingWorker) mais, d'après ce que j'ai compris, ceux-ci ne disposent d'aucune sorte de mécanisme de mise en file d'attente et de répartition des événements, ce dont dépend invokeLater().

Au lieu de cela, j'ai fini par donner à mon thread d'arrière-plan une file d'attente bloquante, à laquelle d'autres threads envoient des messages, et le thread exécute essentiellement une boucle de réception, bloquant jusqu'à ce qu'un message arrive.

En fait, cela pourrait être exactement la façon dont on implémenterait un comportement de type EDT dans un thread d'arrière-plan (ou pas ?). D'un autre côté, j'aime la simplicité d'un thread qui se balance inerte, traitant les "gouttelettes de travail" lorsqu'elles lui sont envoyées par une file d'attente invisible dans le ciel. Java offre-t-il un moyen de créer un tel "fil de travail piloté par les événements" ? Ou est-ce que la mise en file d'attente des messages est le bon moyen de le faire, après tout ? Dans le même ordre d'idées, y a-t-il des inconvénients à l'utilisation de l'option invokeLater() la technique du passage de messages ?

Answer 1

En Platine de conception producteur-consommateur (ce que vous utilisez avec votre file d'attente bloquante) n'est qu'une approche différente pour résoudre une autre classe de problèmes ; EDT utilise la fonction Modèle de conception du travailleur . Jetez un coup d'œil aux deux modèles de conception et voyez lequel répond le mieux à vos besoins.

• Le modèle producteur-consommateur est généralement utilisé lorsque plusieurs threads exécutent des tâches indépendantes séparément.
• Le modèle Worker, employé par l'EDT, est utilisé pour canaliser le résultat de plusieurs tâches dans un seul thread (dans ce cas, le thread de l'interface graphique).

Bien sûr, vous pouvez prendre le modèle Producer-Consumer et obtenir un comportement similaire à celui du modèle Worker si vous avez une seule file d'attente et un seul consommateur avec plusieurs producteurs, mais cela ne fait que souligner la flexibilité des modèles de conception. L'idée, une fois de plus, est que le choix d'un modèle de conception est basé sur ce qui fonctionne le mieux dans votre situation particulière - il n'y a pas de mauvais choix particulier lorsque les modèles sont suffisamment flexibles pour s'adapter au comportement que vous souhaitez.

Answer 2

Vous devriez jeter un coup d'œil à java.util.concurrent, plus spécifiquement à Exécuteur testamentaire qui ne sont généralement qu'un pool de threads capable de traiter une requête de ce type : executor.execute(runnableTask); . Si vous voulez qu'un seul thread traite toutes les demandes, alors créez votre thread avec un thread unique : executor = Executors.newSingleThreadExecutor()' . Il existe également des ExecutorService qui peuvent renvoyer une valeur lorsque la tâche est terminée.