public class

SimpleAsyncTaskExecutor

extends CustomizableThreadCreator
implements Serializable AsyncTaskExecutor
java.lang.Object
   ↳ org.springframework.util.CustomizableThreadCreator
     ↳ org.springframework.core.task.SimpleAsyncTaskExecutor

Class Overview

TaskExecutor implementation that fires up a new Thread for each task, executing it asynchronously.

Supports limiting concurrent threads through the "concurrencyLimit" bean property. By default, the number of concurrent threads is unlimited.

NOTE: This implementation does not reuse threads! Consider a thread-pooling TaskExecutor implementation instead, in particular for executing a large number of short-lived tasks.

See Also

Summary

Constants
int NO_CONCURRENCY Switch concurrency 'off': that is, don't allow any concurrent invocations.
int UNBOUNDED_CONCURRENCY Permit any number of concurrent invocations: that is, don't throttle concurrency.
[Expand]
Inherited Constants
From interface org.springframework.core.task.AsyncTaskExecutor
Public Constructors
SimpleAsyncTaskExecutor()
Create a new SimpleAsyncTaskExecutor with default thread name prefix.
SimpleAsyncTaskExecutor(String threadNamePrefix)
Create a new SimpleAsyncTaskExecutor with the given thread name prefix.
SimpleAsyncTaskExecutor(ThreadFactory threadFactory)
Create a new SimpleAsyncTaskExecutor with the given external thread factory.
Public Methods
void execute(Runnable task, long startTimeout)
Executes the given task, within a concurrency throttle if configured (through the superclass's settings).
void execute(Runnable task)
Executes the given task, within a concurrency throttle if configured (through the superclass's settings).
final int getConcurrencyLimit()
Return the maximum number of parallel accesses allowed.
final ThreadFactory getThreadFactory()
Return the external factory to use for creating new Threads, if any.
final boolean isThrottleActive()
Return whether this throttle is currently active.
void setConcurrencyLimit(int concurrencyLimit)
Set the maximum number of parallel accesses allowed.
void setThreadFactory(ThreadFactory threadFactory)
Specify an external factory to use for creating new Threads, instead of relying on the local properties of this executor.
<T> Future<T> submit(Callable<T> task)
Submit a Callable task for execution, receiving a Future representing that task.
Future<?> submit(Runnable task)
Submit a Runnable task for execution, receiving a Future representing that task.
Protected Methods
void doExecute(Runnable task)
Template method for the actual execution of a task.
[Expand]
Inherited Methods
From class org.springframework.util.CustomizableThreadCreator
From class java.lang.Object
From interface java.util.concurrent.Executor
From interface org.springframework.core.task.AsyncTaskExecutor
From interface org.springframework.core.task.TaskExecutor

Constants

public static final int NO_CONCURRENCY

Also: SpringCore

Switch concurrency 'off': that is, don't allow any concurrent invocations.

Constant Value: 0 (0x00000000)

public static final int UNBOUNDED_CONCURRENCY

Also: SpringCore

Permit any number of concurrent invocations: that is, don't throttle concurrency.

Constant Value: -1 (0xffffffff)

Public Constructors

public SimpleAsyncTaskExecutor ()

Also: SpringCore

Create a new SimpleAsyncTaskExecutor with default thread name prefix.

public SimpleAsyncTaskExecutor (String threadNamePrefix)

Also: SpringCore

Create a new SimpleAsyncTaskExecutor with the given thread name prefix.

Parameters
threadNamePrefix the prefix to use for the names of newly created threads

public SimpleAsyncTaskExecutor (ThreadFactory threadFactory)

Also: SpringCore

Create a new SimpleAsyncTaskExecutor with the given external thread factory.

Parameters
threadFactory the factory to use for creating new Threads

Public Methods

public void execute (Runnable task, long startTimeout)

Also: SpringCore

Executes the given task, within a concurrency throttle if configured (through the superclass's settings).

Executes urgent tasks (with 'immediate' timeout) directly, bypassing the concurrency throttle (if active). All other tasks are subject to throttling.

Parameters
task the Runnable to execute (never null)
startTimeout the time duration (milliseconds) within which the task is supposed to start. This is intended as a hint to the executor, allowing for preferred handling of immediate tasks. Typical values are TIMEOUT_IMMEDIATE or TIMEOUT_INDEFINITE (the default as used by execute(Runnable)).
See Also

public void execute (Runnable task)

Also: SpringCore

Executes the given task, within a concurrency throttle if configured (through the superclass's settings).

Parameters
task the Runnable to execute (never null)
See Also

public final int getConcurrencyLimit ()

Also: SpringCore

Return the maximum number of parallel accesses allowed.

public final ThreadFactory getThreadFactory ()

Also: SpringCore

Return the external factory to use for creating new Threads, if any.

public final boolean isThrottleActive ()

Also: SpringCore

Return whether this throttle is currently active.

Returns
  • true if the concurrency limit for this instance is active
See Also

public void setConcurrencyLimit (int concurrencyLimit)

Also: SpringCore

Set the maximum number of parallel accesses allowed. -1 indicates no concurrency limit at all.

In principle, this limit can be changed at runtime, although it is generally designed as a config time setting. NOTE: Do not switch between -1 and any concrete limit at runtime, as this will lead to inconsistent concurrency counts: A limit of -1 effectively turns off concurrency counting completely.

See Also

public void setThreadFactory (ThreadFactory threadFactory)

Also: SpringCore

Specify an external factory to use for creating new Threads, instead of relying on the local properties of this executor.

You may specify an inner ThreadFactory bean or also a ThreadFactory reference obtained from JNDI (on a Java EE 6 server) or some other lookup mechanism.

See Also

public Future<T> submit (Callable<T> task)

Also: SpringCore

Submit a Callable task for execution, receiving a Future representing that task. The Future will return the Callable's result upon completion.

Parameters
task the Callable to execute (never null)
Returns
  • a Future representing pending completion of the task

public Future<?> submit (Runnable task)

Also: SpringCore

Submit a Runnable task for execution, receiving a Future representing that task. The Future will return a null result upon completion.

Parameters
task the Runnable to execute (never null)
Returns
  • a Future representing pending completion of the task

Protected Methods

protected void doExecute (Runnable task)

Also: SpringCore

Template method for the actual execution of a task.

The default implementation creates a new Thread and starts it.

Parameters
task the Runnable to execute
See Also