Steuerprogramme für verwaltete Tasks konfigurieren

Sie können ManagedExecutorService-Instanzen konfigurieren, um asynchrone Tasks mit dem angegebenen Threadkontext auszuführen. Das bewährte Verfahren ist für Java™ EE -Anwendungen, um die direkte Verwaltung ihrer eigenen Threads zu vermeiden. Daher erweitert die ManagedExecutorService die JSE ExecutorService , um eine Möglichkeit zum Starten asynchroner Tasks in einer Anwendungsserverumgebung bereitzustellen. Sie können ManagedExecutorService auch so konfigurieren, dass verschiedene Threadkontexte, die für Java EE -Anwendungen relevant sind, an den Thread der asynchronen Task weitergegeben werden.

Informationen zu dieser Task

Wichtig: In Libertyhaben verwaltete Steuerprogramme keine eigenen Thread-Pools. Tasks, die an Instanzen des verwalteten Steuerprogramms übergeben werden, werden im allgemeinen Thread-Pool des Liberty -Steuerprogramms ausgeführt.

Der ManagedExecutorService ist unter dem Feature <concurrent-1.0> verfügbar und wird in der Datei server.xml wie folgt aktiviert:

<featureManager>
    <feature>concurrent-1.0</feature>
</featureManager>

Die Weitergabe von Kontext an den Thread einer Task, die vom ManagedExecutorService ausgeführt wird, wird vom Kontextservice gesteuert. Eine Standardinstanz des Kontextservice (DefaultContextService) wird vom Server erstellt und so konfiguriert, dass mindestens classloaderContext, jeeMetadataContext und securityContext weitergegeben werden. Diese Standardinstanz des Kontextservice wird verwendet, wenn ein ManagedExecutorService erstellt wird, der nicht auf eine bestimmte Kontextserviceinstanz verweist, oder wenn eine Kontextserviceinstanz darin direkt konfiguriert wird. Weitere Informationen zu Kontextserviceinstanzen finden Sie im Abschnitt zur Konfiguration von Instanzen des Threadkontextservice.

Eine Standardinstanz von ManagedExecutorService (DefaultManagedExecutorService) ist als java:comp/DefaultManagedExecutorService verfügbar. Sie verwendet die Standardkontextserviceinstanz zum Erfassen und Weitergeben des Threadkontextes.

Parallelitätsrichtlinien konfigurieren parallelitätsrelevantes Verhalten und Einschränkungen für verwaltete Steuerprogramme, wie z. B. maximale Parallelität und maximale Warteschlangengröße. Standardmäßig verwenden verwaltete, Steuerprogramme eine Standardinstanz (defaultConcurrencyPolicy) mit unbegrenzten Einschränkungen mit einem concurrencyPolicy-Konfigurationselement. Diese Standardparallelitätsrichtlinie wird verwendet, wenn Sie ein verwaltetes Steuerprogramm konfigurieren, ohne ein bestimmtes concurrencyPolicy-Element als verschachteltes Element zu referenzieren oder es direkt als solches zu konfigurieren. Wenn mehrere verwaltete Steuerprogramme oder andere Konfigurationselemente dasselbe concurrencyPolicy-Element referenzieren, gelten die Einschränkungen in dieser Richtlinie für alle diese verwalteten Steuerprogramminstanzen und weitere konfigurierte Ressourcen. Sie können auch ein verwaltetes Steuerprogramm mit einer Parallelitätsrichtlinie für Tasks mit langer Laufzeit konfigurieren, das für Tasks gilt, deren Ausführungseigenschaft LONGRUNNING_HINT auf true gesetzt ist. Die über das concurrencyPolicy-Element und das concurrencyPolicy-Element für lange Laufzeit angegebene Konfiguration gilt für Tasks, die übergeben wurden, um so schnell wie möglich ausgeführt zu werden. Die Konfiguration gilt nicht für terminierte Tasks.

Vorgehensweise

Beispielkonfiguration in der Datei server.xml:

Instanz des verwalteten Steuerprogrammservice, die in JNDI mit dem Namen concurrent/execSvcregistriert ist und die Standardkontextserviceinstanz verwendet:
```
<managedExecutorService jndiName="concurrent/execSvc"/>
```
Instanz des verwalteten Steuerprogrammservice mit maximal fünf gleichzeitigen Threads und einem Kontextservice, der so konfiguriert ist, dass nur der jeeMetadataContext -Kontext weitergegeben wird:
```
<managedExecutorService jndiName="concurrent/execSvc1">
	<contextService>
		<jeeMetadataContext/>
	</contextService>
       <concurrencyPolicy max="5"/>
</managedExecutorService>
```

Instanz des Managed Executor Service mit Kontextservice, der für die Weitergabe von classloaderContext und securityContextkonfiguriert ist:

<managedExecutorService jndiName="concurrent/execSvc2">
	<contextService>
		<classloaderContext/>
		<securityContext/>
	</contextService>
</managedExecutorService>

Threadkontextservice, der so konfiguriert ist, dass nur der jeeMetadataContext -Kontext weitergegeben wird, und eine Richtlinie für gemeinsamen Zugriff, die maximal vier gleichzeitige Threads und eine Warteschlangengröße von zwanzig angibt, die beide von mehreren Instanzen des Steuerprogrammservice gemeinsam genutzt werden. Das verwaltete Steuerprogramm concurrent/execSvc4 hat ein zusätzliches Konfigurationselement concurrencyPolicy , das maximal zwei gleichzeitige Threads für Tasks mit langer Laufzeit angibt:
```
<contextService id="contextSvc1">
	<jeeMetadataContext/>
</contextService>

<concurrencyPolicy id="normal" max="4" maxQueueSize="20"/>

<concurrencyPolicy id="longRunning" max="2"/>

<managedExecutorService 
    jndiName="concurrent/execSvc3" 
    contextServiceRef="contextSvc1" 
    concurrencyPolicyRef="normal"/>

<managedExecutorService 
    jndiName="concurrent/execSvc4" 
    contextServiceRef="contextSvc1" 
    concurrencyPolicyRef="normal" 
    longRunningPolicyRef="longRunning"/>
```
Threadkontextservice, der aus dem vorherigen Beispiel übernimmt und die Weitergabe des classloaderContext -Kontexts hinzufügt und von einer Serviceinstanz eines verwalteten Steuerprogramms verwendet wird:
```
<contextService id="contextSvc2" baseContextRef="contextSvc1">
	<classloaderContext/>
</contextService>

<managedExecutorService jndiName="concurrent/execSvc5" contextServiceRef="contextSvc2"/>
```

Beispiel

Verwaltete Steuerprogrammserviceinstanzen können in Anwendungskomponenten injiziert werden (mithilfe von @Resource) oder mit Ressourcenumgebungsreferenzen (resource-env-ref) gesucht werden. Unabhängig davon, wie die Instanz abgerufen wird, können Sie sie austauschbar als javax.enterprise.concurrent.ManagedExecutorService oder als zugehörige java.util.concurrent.ExecutorSerivce -Superklasse verwenden.

Beispiel, das das verwaltete Standardsteuerprogramm sucht:

ManagedExecutorService executor = 
    (ManagedExecutorService) new InitialContext().lookup(
        "java:comp/DefaultManagedExecutorService");
executor.submit(doSomethingInParallel);

Beispiel, in dem @Resource als java.util.concurrent.ExecutorService injiziert wird:

@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();

Beispiel, in dem @Resource als javax.enterprise.concurrent.ManagedExecutorService injiziert wird:

@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();

Beispiel für die Verwendung von <resource-env-ref> für java.util.concurrent.ExecutorService in der Datei 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>

Beispielsuche, die eine Ressourcenumgebungsreferenz verwendet:

ExecutorService execSvc2 = 
    (ExecutorService) new InitialContext().lookup("java:comp/env/concurrent/execSvc2");

futures = execSvc2.invokeAll(Arrays.asList(task1, task2, task3));

Beispiel für die Verwendung von <resource-env-ref> für javax.enterprise.concurrent.ManagedExecutorService in der Datei 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>

Beispielsuche mit Verwendung einer Ressourcenumgebungsreferenz und Umsetzung in ManagedExecutorService:

ManagedExecutorService execSvc2 = 
    (ManagedExecutorService) new InitialContext().lookup("java:comp/env/concurrent/execSvc2");

futures = execSvc2.invokeAll(Arrays.asList(task1, task2, task3));