Package org.springframework.context

# Interface SmartLifecycle

All Superinterfaces:
  `Lifecycle`, `Phased`

All Known Implementing Classes:
  `ExecutorConfigurationSupport`, `ScheduledExecutorFactoryBean`, `SimpleAsyncTaskScheduler`, `ThreadPoolExecutorFactoryBean`, `ThreadPoolTaskExecutor`, `ThreadPoolTaskScheduler`

public interface SmartLifecycle extends Lifecycle, Phased
An extension of the `Lifecycle` interface for those objects that require to be started upon `ApplicationContext` refresh and/or shutdown in a particular order.

The `isAutoStartup()` return value indicates whether this object should be started at the time of a context refresh. The callback-accepting `stop(Runnable)` method is useful for objects that have an asynchronous shutdown process. Any implementation of this interface must invoke the callback's `run()` method upon shutdown completion to avoid unnecessary delays in the overall `ApplicationContext` shutdown.

This interface extends `Phased`, and the `getPhase()` method's return value indicates the phase within which this `Lifecycle` component should be started and stopped. The startup process begins with the lowest phase value and ends with the highest phase value (`Integer.MIN_VALUE` is the lowest possible, and `Integer.MAX_VALUE` is the highest possible). The shutdown process will apply the reverse order. Any components with the same value will be arbitrarily ordered within the same phase.

Example: if component B depends on component A having already started, then component A should have a lower phase value than component B. During the shutdown process, component B would be stopped before component A.

Any explicit "depends-on" relationship will take precedence over the phase order such that the dependent bean always starts after its dependency and always stops before its dependency.

Any `Lifecycle` components within the context that do not also implement `SmartLifecycle` will be treated as if they have a phase value of `0`. This allows a `SmartLifecycle` component to start before those `Lifecycle` components if the `SmartLifecycle` component has a negative phase value, or the `SmartLifecycle` component may start after those `Lifecycle` components if the `SmartLifecycle` component has a positive phase value.

Note that, due to the auto-startup support in `SmartLifecycle`, a `SmartLifecycle` bean instance will usually get initialized on startup of the application context in any case. As a consequence, the bean definition lazy-init flag has very limited actual effect on `SmartLifecycle` beans.

Since:
  3.0
Author:
  Mark Fisher, Juergen Hoeller, Sam Brannen
See Also:
  - `LifecycleProcessor`
  - `ConfigurableApplicationContext`

## Field Summary

Fields
Modifier and Type
Field
Description
`static final int`
`DEFAULT_PHASE`
The default phase for `SmartLifecycle`: `Integer.MAX_VALUE`.

## Method Summary

Modifier and Type
Method
Description
`default int`
`getPhase()`
Return the phase that this lifecycle object is supposed to run in.
`default boolean`
`isAutoStartup()`
Returns `true` if this `Lifecycle` component should get started automatically by the container at the time that the containing `ApplicationContext` gets refreshed.
`default void`
`stop(Runnable callback)`
Indicates that a Lifecycle component must stop if it is currently running.

### Methods inherited from interface org.springframework.context.Lifecycle

`isRunning, start, stop`

## Field Details

### DEFAULT_PHASE

static final int DEFAULT_PHASE
The default phase for `SmartLifecycle`: `Integer.MAX_VALUE`.

This is different from the common phase `0` associated with regular `Lifecycle` implementations, putting the typically auto-started `SmartLifecycle` beans into a later startup phase and an earlier shutdown phase.

Note that certain `SmartLifecycle` components come with a different default phase: for example, executors/schedulers with `Integer.MAX_VALUE / 2`.

Since:
  5.1
See Also:
  - `getPhase()`
  - `ExecutorConfigurationSupport.DEFAULT_PHASE`
  - `DefaultLifecycleProcessor.setTimeoutPerShutdownPhase(long)`
  - Constant Field Values

## Method Details

### isAutoStartup

default boolean isAutoStartup()
Returns `true` if this `Lifecycle` component should get started automatically by the container at the time that the containing `ApplicationContext` gets refreshed.

A value of `false` indicates that the component is intended to be started through an explicit `Lifecycle.start()` call instead, analogous to a plain `Lifecycle` implementation.

The default implementation returns `true`.

See Also:
  - `Lifecycle.start()`
  - `getPhase()`
  - `LifecycleProcessor.onRefresh()`
  - `ConfigurableApplicationContext.refresh()`

### stop

default void stop(Runnable callback)
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 `Lifecycle.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).

See Also:
  - `Lifecycle.stop()`
  - `getPhase()`

### getPhase

default int getPhase()
Return the phase that this lifecycle object is supposed to run in.

The default implementation returns `DEFAULT_PHASE` in order to let `stop()` callbacks execute before regular `Lifecycle` implementations.

Specified by:
  `getPhase` in interface `Phased`
See Also:
  - `isAutoStartup()`
  - `Lifecycle.start()`
  - `stop(Runnable)`
  - `DefaultLifecycleProcessor.getPhase(Lifecycle)`