Spring Framework 6.1.4 · org.springframework.scheduling.concurrent.ExecutorLifecycleDelegate

Modifier and Type	Field and Description
private int	executingTaskCount
private final ExecutorService	executor
private volatile boolean	paused
private final Lock	pauseLock
private volatile boolean	shutdown
private Runnable	stopCallback
private final Condition	unpaused

Access	Constructor and Description
public	ExecutorLifecycleDelegate(ExecutorService executor)

Method Summary

Modifier and Type	Method and Description
pack-priv void	afterExecute()
pack-priv void	beforeExecute(Thread thread)
public boolean	isRunning() Implements org.springframework.context.Lifecycle.isRunning. Check whether this component is currently running.
pack-priv void	markShutdown()
public void	start() Implements org.springframework.context.Lifecycle.start. Start this component.
public void	stop() Implements org.springframework.context.Lifecycle.stop. Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method.
public void	stop(Runnable callback) Overrides default org.springframework.context.SmartLifecycle.stop. Indicates that a Lifecycle component must stop if it is currently running.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

executingTaskCount	back to summary
private int executingTaskCount

executor	back to summary
private final ExecutorService executor

paused	back to summary
private volatile boolean paused

pauseLock	back to summary
private final Lock pauseLock

shutdown	back to summary
private volatile boolean shutdown

stopCallback	back to summary
private Runnable stopCallback Annotations @Nullable

unpaused	back to summary
private final Condition unpaused

ExecutorLifecycleDelegate	back to summary
public ExecutorLifecycleDelegate(ExecutorService executor)

Method Detail

afterExecute	back to summary
pack-priv void afterExecute()

beforeExecute	back to summary
pack-priv void beforeExecute(Thread thread)

isRunning back to summary

isRunning	back to summary
public boolean isRunning() Implements org.springframework.context.Lifecycle.isRunning. Doc from org.springframework.context.Lifecycle.isRunning. Check whether this component is currently running. In the case of a container, this will return `true` only if all components that apply are currently running. Returns:boolean whether the component is currently running Annotations @Override

public boolean isRunning()

Implements org.springframework.context.Lifecycle.isRunning.

Doc from org.springframework.context.Lifecycle.isRunning.

Check whether this component is currently running.

In the case of a container, this will return true only if all components that apply are currently running.

Returns:boolean

whether the component is currently running

Annotations

@Override

markShutdown	back to summary
pack-priv void markShutdown()

start	back to summary
public void start() Implements org.springframework.context.Lifecycle.start. Doc from org.springframework.context.Lifecycle.start. Start this component. Should not throw an exception if the component is already running. In the case of a container, this will propagate the start signal to all components that apply. Annotations @Override

start

back to summary

public void start()

Implements org.springframework.context.Lifecycle.start.

Doc from org.springframework.context.Lifecycle.start.

Start this component.

Should not throw an exception if the component is already running.

In the case of a container, this will propagate the start signal to all components that apply.

Annotations

@Override

stop back to summary

stop	back to summary
public void stop() Implements org.springframework.context.Lifecycle.stop. Doc from org.springframework.context.Lifecycle.stop. Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method. Consider implementing `SmartLifecycle` and its `stop(Runnable)` variant when asynchronous stop behavior is necessary. Note that this stop notification is not guaranteed to come before destruction: On regular shutdown, `Lifecycle` beans will first receive a stop notification before the general destruction callbacks are being propagated; however, on hot refresh during a context's lifetime or on aborted refresh attempts, a given bean's destroy method will be called without any consideration of stop signals upfront. Should not throw an exception if the component is not running (not started yet). In the case of a container, this will propagate the stop signal to all components that apply. Annotations @Override

public void stop()

Implements org.springframework.context.Lifecycle.stop.

Doc from org.springframework.context.Lifecycle.stop.

Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method. Consider implementing SmartLifecycle and its stop(Runnable) variant when asynchronous stop behavior is necessary.

Note that this stop notification is not guaranteed to come before destruction: On regular shutdown, Lifecycle beans will first receive a stop notification before the general destruction callbacks are being propagated; however, on hot refresh during a context's lifetime or on aborted refresh attempts, a given bean's destroy method will be called without any consideration of stop signals upfront.

Should not throw an exception if the component is not running (not started yet).

In the case of a container, this will propagate the stop signal to all components that apply.

Annotations

@Override

stop back to summary

stop	back to summary
public void stop(Runnable callback) Overrides default org.springframework.context.SmartLifecycle.stop. Doc from org.springframework.context.SmartLifecycle.stop. Indicates that a Lifecycle component must stop if it is currently running. The provided callback is used by the `LifecycleProcessor` to support an ordered, and potentially concurrent, shutdown of all components having a common shutdown order value. The callback must be executed after the `SmartLifecycle` component does indeed stop. The `LifecycleProcessor` will call only this variant of the `stop` method; i.e. `Lifecycle#stop()` will not be called for `SmartLifecycle` implementations unless explicitly delegated to within the implementation of this method. The default implementation delegates to `stop()` and immediately triggers the given callback in the calling thread. Note that there is no synchronization between the two, so custom implementations may at least want to put the same steps within their common lifecycle monitor (if any). Annotations @Override

public void stop(Runnable callback)

Overrides default org.springframework.context.SmartLifecycle.stop.

Doc from org.springframework.context.SmartLifecycle.stop.

Indicates that a Lifecycle component must stop if it is currently running.

The provided callback is used by the LifecycleProcessor to support an ordered, and potentially concurrent, shutdown of all components having a common shutdown order value. The callback must be executed after the SmartLifecycle component does indeed stop.

The LifecycleProcessor will call only this variant of the stop method; i.e. Lifecycle#stop() will not be called for SmartLifecycle implementations unless explicitly delegated to within the implementation of this method.

The default implementation delegates to stop() and immediately triggers the given callback in the calling thread. Note that there is no synchronization between the two, so custom implementations may at least want to put the same steps within their common lifecycle monitor (if any).

Annotations

@Override

pack-priv final Class ExecutorLifecycleDelegate

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail