type=page
status=published
title=Main Components of the Concurrency Utilities
next=concurrency-utilities003.html
prev=concurrency-utilities001.html
~~~~~~
= Main Components of the Concurrency Utilities


[[CIHFBCFH]]

[[main-components-of-the-concurrency-utilities]]
Main Components of the Concurrency Utilities
--------------------------------------------

Concurrent resources are managed objects that provide concurrency
capabilities to Java EE applications. In GlassFish Server, you configure
concurrent resources and then make them available for use by application
components such as servlets and enterprise beans. Concurrent resources
are accessed through JNDI lookup or resource injection.

The primary components of the concurrency utilities are as follows.

* `ManagedExecutorService`: A managed executor service is used by
applications to execute submitted tasks asynchronously. Tasks are
executed on threads that are started and managed by the container. The
context of the container is propagated to the thread executing the task.
+
For example, by using an `ManagedExecutorService.submit()` call, a task,
such as the GenerateReportTask, could be submitted to execute at a later
time and then, by using the `Future` object callback, retrieve the
result when it becomes available.
* `ManagedScheduledExecutorService`: A managed scheduled executor
service is used by applications to execute submitted tasks
asynchronously at specific times. Tasks are executed on threads that are
started and managed by the container. The context of the container is
propagated to the thread executing the task. The API provides the
scheduling functionality that allows users to set a specific date/time
for the Task execution programmatically in the application.
* `ContextService`: A context service is used to create dynamic proxy
objects that capture the context of a container and enable applications
to run within that context at a later time or be submitted to a Managed
Executor Service. The context of the container is propagated to the
thread executing the task.
* `ManagedThreadFactory`: A managed thread factory is used by
applications to create managed threads. The threads are started and
managed by the container. The context of the container is propagated to
the thread executing the task. This object can also be used to provide
custom factories for specific use cases (with custom Threads) and, for
example, set specific/proprietary properties to these objects.
