Développement de tâches pour une exécution de code en parallèle
Vous pouvez exécuter des opérations en parallèle en encapsulant le code dans une tâche appelable ou exécutable et en soumettant ou en planifiant son exécution auprès d'un programme d'exécution.
Avant de commencer
Le cas échéant, votre administrateur peut utiliser la console d'administration pour configurer au moins un gestionnaire de travaux ou modifier les paramètres du gestionnaire de travaux par défaut.
Pourquoi et quand exécuter cette tâche
Pour exécuter le code en parallèle, encapsulez-le dans une tâche appelable ou exécutable et soumettez ou planifiez son exécution auprès d'un programme d'exécution géré.
Procédure
- Implémentez une tâche appelable ou exécutable.
Une tâche implémente l'interface java.util.concurrent.Callable ou java.lang.Runnable. Par exemple, vous pouvez créer une tâche qui permet de s'abonner de manière dynamique à une rubrique et à n'importe quel composant.
class SampleTask implements Callable<Object> { Set<MessageListener> listeners = Collections.newSetFromMap(new ConcurrentHashMap<MessageListener, Boolean>(); Topic targetTopic; TopicConnectionFactory tcf; public SampleWork(TopicConnectionFactory tcf, Topic targetTopic) { this.targetTopic = targetTopic; this.tcf = tcf; } public void addMessageListener(MessageListener listener) { listeners.add(listener); } public Object call() throws JMSException { // setup our JMS stuff.TopicConnection tc = tcf.createConnection(); try { TopicSession sess = tc.createSession(false, Session.AUTOACK); tc.start(); while( !Thread.currentThread().isInterrupted() ) { // block for up to 5 seconds. Message msg = sess.receiveMessage(5000); if( msg != null ) for (MessageListener listener : listeners) listener.onMessage(msg); } tc.close(); } finally { if (tc != null) tc.close(); } } }
Par conséquent, tout composant peut ajouter un programme d'écoute de message à la demande, ce qui permet aux composants de s'abonner à une rubrique. Ce mécanisme est plus souple que l'attribution de sa propre unité d'exécution à chaque abonné client.
- Déterminez le nombre de gestionnaires de travaux requis par ce composant d'application.
- Recherchez le(s) gestionnaire(s) de travaux à l'aide du programme d'exécution géré, de la fabrique d'unités d'exécution, de la référence d'environnement de ressource du service contextuel ou de la référence de ressource du gestionnaire de travaux (ou nom logique) dans l'espace de nom java:comp. (Pour plus d'informations sur les références d'environnement de ressource et sur les références de ressource, voir la rubrique Références).
La référence d'environnement de ressource du programme d'exécution géré (dans notre exemple, concurrent/myWorkManager) doit être déclarée en tant que référence d'environnement de ressource dans le descripteur de déploiement d'application ou dans une annotation @Resource.InitialContext ic = new InitialContext(); ManagedExecutorService executor = (ManagedExecutorService)ic.lookup("java:comp/env/concurrent/myWorkManager");
- Appelez la méthode ManagedExecutorService.submit() à l'aide de l'instance de tâche appelable ou exécutable en tant que paramètre. Exemple :
Callable<Boolean> task = new MyTask(...); Future<Boolean> future = executor.submit(task);
Future est un descripteur qui établit un lien entre le composant et la tâche soumise.
- Facultatif : Si votre composant d'application doit attendre la fin de l'exécution de l'une ou plusieurs de ses tâches, appelez la méthode Future.get(). Exemple :
Future<String> futureA = executor.submit(taskA); Future<String> futureB = executor.submit(taskB); futureA.get(5, TimeUnit.SECONDS); futureB.get(5, TimeUnit.SECONDS);
Sinon, utilisez la méthode invokeAll() pour soumettre plusieurs tâches et attendez qu'elles soient toutes terminées. Exemple :
tasks = Arrays.asList(taskA, taskB); futures = executor.invokeAll(tasks, 5, TimeUnit.SECONDS); // we can check future.isDone() to see which, if any, finished.
Cette méthode prend une collection de tâches pour laquelle le composant souhaite attendre la fin de l'exécution de tous les objets de travail. Vous pouvez également spécifier un délai d'attente.
- Utilisez la méthode Future.cancel(true) pour tenter d'interrompre la tâche.
Implémentez la tâche dans le but de répondre immédiatement à l'interruption ou essayez d'arrêter l'exécution dès que possible.
Sous-rubriques
Tâches appelables et exécutables
Dans Concurrency Utilities for Java EE, une tâche appelable ou exécutable est utilisée par des composants d'application pour exécuter du code en parallèle du contexte Java Platform, Enterprise Edition (Java EE) de l'unité d'exécution de soumission.Exemple : Création de tâches appelables et exécutables
Vous pouvez créer une tâche qui permet de s'abonner de manière dynamique à une rubrique, et tout composant peut ajouter un programme d'écoute de message à la demande.Exemple : Utilisation de connexions avec des accès concurrents
Une méthode exécutable ou appelable peut utiliser les connexions que le component par lequel elle a été créée a obtenues à l'aide de références de ressource java:comp.


http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tasb_devwkobj
Nom du fichier : tasb_devwkobj.html