Configuration des programmes d'exécution gérés

Vous pouvez configurer les instances ManagedExecutorService pour exécuter les tâches asynchrones avec le contexte d'unité d'exécution spécifié. Il est recommandé pour les applications Java™ EE d'éviter la gestion directe de leurs propres unités d'exécution, c'est pourquoi le ManagedExecutorService étend le JSE ExecutorService afin de permettre de démarrer les tâches asynchrones dans un environnement de serveur d'applications. Vous pouvez également configurer le ManagedExecutorService afin de propager plusieurs contextes d'unités d'exécution pertinents pour les applications Java EE sur l'unité d'exécution de la tâche asynchrone.

Pourquoi et quand exécuter cette tâche

Important : Dans Liberty, les programmes d'exécution gérés n'ont pas de pools d'unités d'exécution propres. Les tâches soumises aux instances des programmes d'exécution gérés s'exécutent dans le pool d'unités d'exécution Liberty commun.
Le ManagedExecutorService est disponible sous la fonction <concurrent-1.0> et il est activé dans le fichier server.xml comme suit :
<featureManager>
	<feature>concurrent-1.0</feature>
</featureManager>

La propagation de contexte sur l'unité d'exécution d'une tâche exécutée par le ManagedExecutorService est gérée par le service contextuel. Une instance par défaut du service de contexte (DefaultContextService) est créée par le serveur et configurée pour propager au moins classloaderContext, jeeMetadataContext et securityContext. Cette instance de service contextuel par défaut est utilisée si un ManagedExecutorService est créé sans référence à une instance de service contextuel spécifique ou sans configuration directe d'une instance de service contextuel. Pour plus d'informations sur les instances de service contextuel, consultez la rubrique Configuration des instances de service du contexte d'unité d'exécution.

Une instance de programme d'exécution géré par défaut (DefaultManagedExecutorService) est disponible dans java:comp/DefaultManagedExecutorService et utilise l'instance de service contextuel par défaut pour la capture et la propagation des contextes d'unités d'exécution.

[17.0.0.4 and later]Les règles d'accès simultané configurent des comportements et des constraintes liés aux accès simultanés qui s'appliquent à des programmes d'exécution gérés, par exemple, le nombre maximal d'accès simultanés et la taille de file d'attente maximale. Par défaut, les programmes d'exécution gérés utilisent une instance par défaut d'élément de configuration concurrencyPolicy, defaultConcurrencyPolicy, dont les contraintes sont illimitées. Cette règle d'accès simultané par défaut est utilisée si vous configurez un programme d'exécution géré sans faire référence à ou configurer directement un élément concurrencyPolicy spécifique comme élément imbriqué. Si plusieurs programmes d'exécution gérés ou autres éléments de configuration font référence au même élément concurrencyPolicy, les contraintes de cette règle s'appliquent à toutes les instances de programme d'exécution géré et à d'autres ressources configurées. Vous pouvez également configurer un programme d'exécution géré avec une règle d'accès simultané pour des tâches à exécution longue, qui s'applique aux tâches dont la propriété d'exécution LONGRUNNING_HINT a pour valeur true. La configuration qui est spécifiée dans l'élément concurrencyPolicy et l'élément concurrencyPolicy à exécution longue s'appliquent aux tâches qui sont soumises pour être exécutées le plus vite possible. La configuration ne s'applique pas aux tâches programmées.

Procédure

Exemple de configuration dans le fichier server.xml :

Exemple

Les instances de services du programme d'exécution géré peuvent être injectées dans des composants d'applications (à l'aide de @Resource) ou consultées avec des références d'environnement de ressource (resource-env-ref). Indépendamment de la manière dont l'instance est obtenue, vous pouvez l'utiliser de manière interchangeable en tant que javax.enterprise.concurrent.ManagedExecutorService ou sa superclasse java.util.concurrent.ExecutorSerivce.

  • Exemple qui recherche le programme d'exécution géré par défaut :
    ManagedExecutorService executor = 
        (ManagedExecutorService) new InitialContext().lookup(
            "java:comp/DefaultManagedExecutorService");
    executor.submit(doSomethingInParallel);
  • Exemple utilisant @Resource pour injection en java.util.concurrent.ExecutorService :
    @Resource(lookup="concurrent/execSvc1")
    ExecutorService execSvc1;
    
    ...
    
    // submit task to run 
    Future<Integer> future1 = execSvc1.submit(new Callable<Integer>() { 
    	public Integer call() throws Exception { 
    	  // java:comp lookup is possible because <jeeMetadataContext> is configured 
    		DataSource ds = (DataSource) new InitialContext().lookup("java:comp/env/jdbc/ds1");
    		... make updates to the database 
    		return updateCount; 
    	} 
    });  
    Future<Integer> future2 = execSvc1.submit(anotherTaskThatUpdatesADatabase);  
    
    numUpdatesCompleted = future1.get() + future2.get();
  • Exemple utilisant @Resource pour injection en javax.enterprise.concurrent.ManagedExecutorService :
    @Resource(lookup="concurrent/execSvc1")
    ManagedExecutorService execSvc1;
    
    ...
    
    // submit task to run 
    Future<Integer> future1 = execSvc1.submit(new Callable<Integer>() { 
    	public Integer call() throws Exception { 
    	  // java:comp lookup is possible because <jeeMetadataContext> is configured 
    		DataSource ds = (DataSource) new InitialContext().lookup("java:comp/env/jdbc/ds1");
    		... make updates to the database 
    		return updateCount; 
    	} 
    });  
    Future<Integer> future2 = execSvc1.submit(anotherTaskThatUpdatesADatabase);  
    
    numUpdatesCompleted = future1.get() + future2.get();
  • Exemple <resource-env-ref> pour java.util.concurrent.ExecutorService dans le fichier web.xml :
    <resource-env-ref>
    	<resource-env-ref-name>concurrent/execSvc2</resource-env-ref-name>
    	<resource-env-ref-type>java.util.concurrent.ExecutorService</resource-env-ref-type>
    </resource-env-ref>
  • Exemple de consultation qui utilise une référence d'environnement de ressource :
    ExecutorService execSvc2 = 
        (ExecutorService) new InitialContext().lookup("java:comp/env/concurrent/execSvc2");
    
    futures = execSvc2.invokeAll(Arrays.asList(task1, task2, task3));
  • Exemple <resource-env-ref> pour javax.enterprise.concurrent.ManagedExecutorService dans le fichier web.xml :
    <resource-env-ref>
    	<resource-env-ref-name>concurrent/execSvc2</resource-env-ref-name>
    	<resource-env-ref-type>javax.enterprise.concurrent.ManagedExecutorService</resource-env-ref-type>
    </resource-env-ref>
  • Exemple de consultation utilisant une référence d'environnement de ressource et des trantypages dans ManagedExecutorService :
    ManagedExecutorService execSvc2 = 
        (ManagedExecutorService) new InitialContext().lookup("java:comp/env/concurrent/execSvc2");
    
    futures = execSvc2.invokeAll(Arrays.asList(task1, task2, task3));

Icône indiquant le type de rubrique Rubrique Tâche

Nom du fichier : twlp_config_managedexecutor.html