[[appendix.application-properties.core]]
== Core Properties
[cols="4,3,3", options="header"]
|===
|Name|Description|Default Value

|[[application-properties.core.debug]]xref:#application-properties.core.debug[`+debug+`]
|+++Enable debug logs.+++
|`+false+`

|[[application-properties.core.info]]xref:#application-properties.core.info[`+info.*+`]
|+++Arbitrary properties to add to the info endpoint.+++
|

|[[application-properties.core.logging.charset.console]]xref:#application-properties.core.logging.charset.console[`+logging.charset.console+`]
|+++Charset to use for console output.+++
|

|[[application-properties.core.logging.charset.file]]xref:#application-properties.core.logging.charset.file[`+logging.charset.file+`]
|+++Charset to use for file output.+++
|

|[[application-properties.core.logging.config]]xref:#application-properties.core.logging.config[`+logging.config+`]
|+++Location of the logging configuration file. For instance, `classpath:logback.xml` for Logback.+++
|

|[[application-properties.core.logging.exception-conversion-word]]xref:#application-properties.core.logging.exception-conversion-word[`+logging.exception-conversion-word+`]
|+++Conversion word used when logging exceptions.+++
|`+%wEx+`

|[[application-properties.core.logging.file.name]]xref:#application-properties.core.logging.file.name[`+logging.file.name+`]
|+++Log file name (for instance, `myapp.log`). Names can be an exact location or relative to the current directory.+++
|

|[[application-properties.core.logging.file.path]]xref:#application-properties.core.logging.file.path[`+logging.file.path+`]
|+++Location of the log file. For instance, `/var/log`.+++
|

|[[application-properties.core.logging.group]]xref:#application-properties.core.logging.group[`+logging.group.*+`]
|+++Log groups to quickly change multiple loggers at the same time. For instance, `logging.group.db=org.hibernate,org.springframework.jdbc`.+++
|

|[[application-properties.core.logging.include-application-name]]xref:#application-properties.core.logging.include-application-name[`+logging.include-application-name+`]
|+++Whether to include the application name in the logs.+++
|`+true+`

|[[application-properties.core.logging.level]]xref:#application-properties.core.logging.level[`+logging.level.*+`]
|+++Log levels severity mapping. For instance, `logging.level.org.springframework=DEBUG`.+++
|

|[[application-properties.core.logging.log4j2.config.override]]xref:#application-properties.core.logging.log4j2.config.override[`+logging.log4j2.config.override+`]
|+++Overriding configuration files used to create a composite configuration.+++
|

|[[application-properties.core.logging.logback.rollingpolicy.clean-history-on-start]]xref:#application-properties.core.logging.logback.rollingpolicy.clean-history-on-start[`+logging.logback.rollingpolicy.clean-history-on-start+`]
|+++Whether to clean the archive log files on startup.+++
|`+false+`

|[[application-properties.core.logging.logback.rollingpolicy.file-name-pattern]]xref:#application-properties.core.logging.logback.rollingpolicy.file-name-pattern[`+logging.logback.rollingpolicy.file-name-pattern+`]
|+++Pattern for rolled-over log file names.+++
|`+${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz+`

|[[application-properties.core.logging.logback.rollingpolicy.max-file-size]]xref:#application-properties.core.logging.logback.rollingpolicy.max-file-size[`+logging.logback.rollingpolicy.max-file-size+`]
|+++Maximum log file size.+++
|`+10MB+`

|[[application-properties.core.logging.logback.rollingpolicy.max-history]]xref:#application-properties.core.logging.logback.rollingpolicy.max-history[`+logging.logback.rollingpolicy.max-history+`]
|+++Maximum number of archive log files to keep.+++
|`+7+`

|[[application-properties.core.logging.logback.rollingpolicy.total-size-cap]]xref:#application-properties.core.logging.logback.rollingpolicy.total-size-cap[`+logging.logback.rollingpolicy.total-size-cap+`]
|+++Total size of log backups to be kept.+++
|`+0B+`

|[[application-properties.core.logging.pattern.console]]xref:#application-properties.core.logging.pattern.console[`+logging.pattern.console+`]
|+++Appender pattern for output to the console. Supported only with the default Logback setup.+++
|`+%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd'T'HH:mm:ss.SSSXXX}}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}+`

|[[application-properties.core.logging.pattern.correlation]]xref:#application-properties.core.logging.pattern.correlation[`+logging.pattern.correlation+`]
|+++Appender pattern for log correlation. Supported only with the default Logback setup.+++
|

|[[application-properties.core.logging.pattern.dateformat]]xref:#application-properties.core.logging.pattern.dateformat[`+logging.pattern.dateformat+`]
|+++Appender pattern for log date format. Supported only with the default Logback setup.+++
|`+yyyy-MM-dd'T'HH:mm:ss.SSSXXX+`

|[[application-properties.core.logging.pattern.file]]xref:#application-properties.core.logging.pattern.file[`+logging.pattern.file+`]
|+++Appender pattern for output to a file. Supported only with the default Logback setup.+++
|`+%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd'T'HH:mm:ss.SSSXXX}} ${LOG_LEVEL_PATTERN:-%5p} ${PID:- } --- [%t] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}+`

|[[application-properties.core.logging.pattern.level]]xref:#application-properties.core.logging.pattern.level[`+logging.pattern.level+`]
|+++Appender pattern for log level. Supported only with the default Logback setup.+++
|`+%5p+`

|[[application-properties.core.logging.register-shutdown-hook]]xref:#application-properties.core.logging.register-shutdown-hook[`+logging.register-shutdown-hook+`]
|+++Register a shutdown hook for the logging system when it is initialized. Disabled automatically when deployed as a war file.+++
|`+true+`

|[[application-properties.core.logging.threshold.console]]xref:#application-properties.core.logging.threshold.console[`+logging.threshold.console+`]
|+++Log level threshold for console output.+++
|`+TRACE+`

|[[application-properties.core.logging.threshold.file]]xref:#application-properties.core.logging.threshold.file[`+logging.threshold.file+`]
|+++Log level threshold for file output.+++
|`+TRACE+`

|[[application-properties.core.spring.aop.auto]]xref:#application-properties.core.spring.aop.auto[`+spring.aop.auto+`]
|+++Add @EnableAspectJAutoProxy.+++
|`+true+`

|[[application-properties.core.spring.aop.proxy-target-class]]xref:#application-properties.core.spring.aop.proxy-target-class[`+spring.aop.proxy-target-class+`]
|+++Whether subclass-based (CGLIB) proxies are to be created (true), as opposed to standard Java interface-based proxies (false).+++
|`+true+`

|[[application-properties.core.spring.application.admin.enabled]]xref:#application-properties.core.spring.application.admin.enabled[`+spring.application.admin.enabled+`]
|+++Whether to enable admin features for the application.+++
|`+false+`

|[[application-properties.core.spring.application.admin.jmx-name]]xref:#application-properties.core.spring.application.admin.jmx-name[`+spring.application.admin.jmx-name+`]
|+++JMX name of the application admin MBean.+++
|`+org.springframework.boot:type=Admin,name=SpringApplication+`

|[[application-properties.core.spring.application.name]]xref:#application-properties.core.spring.application.name[`+spring.application.name+`]
|+++Application name.+++
|

|[[application-properties.core.spring.autoconfigure.exclude]]xref:#application-properties.core.spring.autoconfigure.exclude[`+spring.autoconfigure.exclude+`]
|+++Auto-configuration classes to exclude.+++
|

|[[application-properties.core.spring.banner.charset]]xref:#application-properties.core.spring.banner.charset[`+spring.banner.charset+`]
|+++Banner file encoding.+++
|`+UTF-8+`

|[[application-properties.core.spring.banner.location]]xref:#application-properties.core.spring.banner.location[`+spring.banner.location+`]
|+++Banner text resource location.+++
|`+classpath:banner.txt+`

|[[application-properties.core.spring.beaninfo.ignore]]xref:#application-properties.core.spring.beaninfo.ignore[`+spring.beaninfo.ignore+`]
|+++Whether to skip search of BeanInfo classes.+++
|`+true+`

|[[application-properties.core.spring.codec.log-request-details]]xref:#application-properties.core.spring.codec.log-request-details[`+spring.codec.log-request-details+`]
|+++Whether to log form data at DEBUG level, and headers at TRACE level.+++
|`+false+`

|[[application-properties.core.spring.codec.max-in-memory-size]]xref:#application-properties.core.spring.codec.max-in-memory-size[`+spring.codec.max-in-memory-size+`]
|+++Limit on the number of bytes that can be buffered whenever the input stream needs to be aggregated. This applies only to the auto-configured WebFlux server and WebClient instances. By default this is not set, in which case individual codec defaults apply. Most codecs are limited to 256K by default.+++
|

|[[application-properties.core.spring.config.activate.on-cloud-platform]]xref:#application-properties.core.spring.config.activate.on-cloud-platform[`+spring.config.activate.on-cloud-platform+`]
|+++Required cloud platform for the document to be included.+++
|

|[[application-properties.core.spring.config.activate.on-profile]]xref:#application-properties.core.spring.config.activate.on-profile[`+spring.config.activate.on-profile+`]
|+++Profile expressions that should match for the document to be included.+++
|

|[[application-properties.core.spring.config.additional-location]]xref:#application-properties.core.spring.config.additional-location[`+spring.config.additional-location+`]
|+++Config file locations used in addition to the defaults.+++
|

|[[application-properties.core.spring.config.import]]xref:#application-properties.core.spring.config.import[`+spring.config.import+`]
|+++Import additional config data.+++
|

|[[application-properties.core.spring.config.location]]xref:#application-properties.core.spring.config.location[`+spring.config.location+`]
|+++Config file locations that replace the defaults.+++
|

|[[application-properties.core.spring.config.name]]xref:#application-properties.core.spring.config.name[`+spring.config.name+`]
|+++Config file name.+++
|`+application+`

|[[application-properties.core.spring.info.build.encoding]]xref:#application-properties.core.spring.info.build.encoding[`+spring.info.build.encoding+`]
|+++File encoding.+++
|`+UTF-8+`

|[[application-properties.core.spring.info.build.location]]xref:#application-properties.core.spring.info.build.location[`+spring.info.build.location+`]
|+++Location of the generated build-info.properties file.+++
|`+classpath:META-INF/build-info.properties+`

|[[application-properties.core.spring.info.git.encoding]]xref:#application-properties.core.spring.info.git.encoding[`+spring.info.git.encoding+`]
|+++File encoding.+++
|`+UTF-8+`

|[[application-properties.core.spring.info.git.location]]xref:#application-properties.core.spring.info.git.location[`+spring.info.git.location+`]
|+++Location of the generated git.properties file.+++
|`+classpath:git.properties+`

|[[application-properties.core.spring.jmx.default-domain]]xref:#application-properties.core.spring.jmx.default-domain[`+spring.jmx.default-domain+`]
|+++JMX domain name.+++
|

|[[application-properties.core.spring.jmx.enabled]]xref:#application-properties.core.spring.jmx.enabled[`+spring.jmx.enabled+`]
|+++Expose management beans to the JMX domain.+++
|`+false+`

|[[application-properties.core.spring.jmx.registration-policy]]xref:#application-properties.core.spring.jmx.registration-policy[`+spring.jmx.registration-policy+`]
|+++JMX Registration policy.+++
|`+fail-on-existing+`

|[[application-properties.core.spring.jmx.server]]xref:#application-properties.core.spring.jmx.server[`+spring.jmx.server+`]
|+++MBeanServer bean name.+++
|`+mbeanServer+`

|[[application-properties.core.spring.jmx.unique-names]]xref:#application-properties.core.spring.jmx.unique-names[`+spring.jmx.unique-names+`]
|+++Whether unique runtime object names should be ensured.+++
|`+false+`

|[[application-properties.core.spring.lifecycle.timeout-per-shutdown-phase]]xref:#application-properties.core.spring.lifecycle.timeout-per-shutdown-phase[`+spring.lifecycle.timeout-per-shutdown-phase+`]
|+++Timeout for the shutdown of any phase (group of SmartLifecycle beans with the same 'phase' value).+++
|`+30s+`

|[[application-properties.core.spring.main.allow-bean-definition-overriding]]xref:#application-properties.core.spring.main.allow-bean-definition-overriding[`+spring.main.allow-bean-definition-overriding+`]
|+++Whether bean definition overriding, by registering a definition with the same name as an existing definition, is allowed.+++
|`+false+`

|[[application-properties.core.spring.main.allow-circular-references]]xref:#application-properties.core.spring.main.allow-circular-references[`+spring.main.allow-circular-references+`]
|+++Whether to allow circular references between beans and automatically try to resolve them.+++
|`+false+`

|[[application-properties.core.spring.main.banner-mode]]xref:#application-properties.core.spring.main.banner-mode[`+spring.main.banner-mode+`]
|+++Mode used to display the banner when the application runs.+++
|`+console+`

|[[application-properties.core.spring.main.cloud-platform]]xref:#application-properties.core.spring.main.cloud-platform[`+spring.main.cloud-platform+`]
|+++Override the Cloud Platform auto-detection.+++
|

|[[application-properties.core.spring.main.keep-alive]]xref:#application-properties.core.spring.main.keep-alive[`+spring.main.keep-alive+`]
|+++Whether to keep the application alive even if there are no more non-daemon threads.+++
|`+false+`

|[[application-properties.core.spring.main.lazy-initialization]]xref:#application-properties.core.spring.main.lazy-initialization[`+spring.main.lazy-initialization+`]
|+++Whether initialization should be performed lazily.+++
|`+false+`

|[[application-properties.core.spring.main.log-startup-info]]xref:#application-properties.core.spring.main.log-startup-info[`+spring.main.log-startup-info+`]
|+++Whether to log information about the application when it starts.+++
|`+true+`

|[[application-properties.core.spring.main.register-shutdown-hook]]xref:#application-properties.core.spring.main.register-shutdown-hook[`+spring.main.register-shutdown-hook+`]
|+++Whether the application should have a shutdown hook registered.+++
|`+true+`

|[[application-properties.core.spring.main.sources]]xref:#application-properties.core.spring.main.sources[`+spring.main.sources+`]
|+++Sources (class names, package names, or XML resource locations) to include in the ApplicationContext.+++
|

|[[application-properties.core.spring.main.web-application-type]]xref:#application-properties.core.spring.main.web-application-type[`+spring.main.web-application-type+`]
|+++Flag to explicitly request a specific type of web application. If not set, auto-detected based on the classpath.+++
|

|[[application-properties.core.spring.mandatory-file-encoding]]xref:#application-properties.core.spring.mandatory-file-encoding[`+spring.mandatory-file-encoding+`]
|+++Expected character encoding the application must use.+++
|

|[[application-properties.core.spring.messages.always-use-message-format]]xref:#application-properties.core.spring.messages.always-use-message-format[`+spring.messages.always-use-message-format+`]
|+++Whether to always apply the MessageFormat rules, parsing even messages without arguments.+++
|`+false+`

|[[application-properties.core.spring.messages.basename]]xref:#application-properties.core.spring.messages.basename[`+spring.messages.basename+`]
|+++Comma-separated list of basenames (essentially a fully-qualified classpath location), each following the ResourceBundle convention with relaxed support for slash based locations. If it doesn't contain a package qualifier (such as "org.mypackage"), it will be resolved from the classpath root.+++
|`+messages+`

|[[application-properties.core.spring.messages.cache-duration]]xref:#application-properties.core.spring.messages.cache-duration[`+spring.messages.cache-duration+`]
|+++Loaded resource bundle files cache duration. When not set, bundles are cached forever. If a duration suffix is not specified, seconds will be used.+++
|

|[[application-properties.core.spring.messages.encoding]]xref:#application-properties.core.spring.messages.encoding[`+spring.messages.encoding+`]
|+++Message bundles encoding.+++
|`+UTF-8+`

|[[application-properties.core.spring.messages.fallback-to-system-locale]]xref:#application-properties.core.spring.messages.fallback-to-system-locale[`+spring.messages.fallback-to-system-locale+`]
|+++Whether to fall back to the system Locale if no files for a specific Locale have been found. if this is turned off, the only fallback will be the default file (e.g. "messages.properties" for basename "messages").+++
|`+true+`

|[[application-properties.core.spring.messages.use-code-as-default-message]]xref:#application-properties.core.spring.messages.use-code-as-default-message[`+spring.messages.use-code-as-default-message+`]
|+++Whether to use the message code as the default message instead of throwing a "NoSuchMessageException". Recommended during development only.+++
|`+false+`

|[[application-properties.core.spring.output.ansi.enabled]]xref:#application-properties.core.spring.output.ansi.enabled[`+spring.output.ansi.enabled+`]
|+++Configures the ANSI output.+++
|`+detect+`

|[[application-properties.core.spring.pid.fail-on-write-error]]xref:#application-properties.core.spring.pid.fail-on-write-error[`+spring.pid.fail-on-write-error+`]
|+++Fails if ApplicationPidFileWriter is used but it cannot write the PID file.+++
|

|[[application-properties.core.spring.pid.file]]xref:#application-properties.core.spring.pid.file[`+spring.pid.file+`]
|+++Location of the PID file to write (if ApplicationPidFileWriter is used).+++
|

|[[application-properties.core.spring.profiles.active]]xref:#application-properties.core.spring.profiles.active[`+spring.profiles.active+`]
|+++Comma-separated list of active profiles. Can be overridden by a command line switch.+++
|

|[[application-properties.core.spring.profiles.default]]xref:#application-properties.core.spring.profiles.default[`+spring.profiles.default+`]
|+++Name of the profile to enable if no profile is active.+++
|`+default+`

|[[application-properties.core.spring.profiles.group]]xref:#application-properties.core.spring.profiles.group[`+spring.profiles.group.*+`]
|+++Profile groups to define a logical name for a related group of profiles.+++
|

|[[application-properties.core.spring.profiles.include]]xref:#application-properties.core.spring.profiles.include[`+spring.profiles.include+`]
|+++Unconditionally activate the specified comma-separated list of profiles (or list of profiles if using YAML).+++
|

|[[application-properties.core.spring.quartz.auto-startup]]xref:#application-properties.core.spring.quartz.auto-startup[`+spring.quartz.auto-startup+`]
|+++Whether to automatically start the scheduler after initialization.+++
|`+true+`

|[[application-properties.core.spring.quartz.jdbc.comment-prefix]]xref:#application-properties.core.spring.quartz.jdbc.comment-prefix[`+spring.quartz.jdbc.comment-prefix+`]
|+++Prefixes for single-line comments in SQL initialization scripts.+++
|`+[#, --]+`

|[[application-properties.core.spring.quartz.jdbc.initialize-schema]]xref:#application-properties.core.spring.quartz.jdbc.initialize-schema[`+spring.quartz.jdbc.initialize-schema+`]
|+++Database schema initialization mode.+++
|`+embedded+`

|[[application-properties.core.spring.quartz.jdbc.platform]]xref:#application-properties.core.spring.quartz.jdbc.platform[`+spring.quartz.jdbc.platform+`]
|+++Platform to use in initialization scripts if the @@platform@@ placeholder is used. Auto-detected by default.+++
|

|[[application-properties.core.spring.quartz.jdbc.schema]]xref:#application-properties.core.spring.quartz.jdbc.schema[`+spring.quartz.jdbc.schema+`]
|+++Path to the SQL file to use to initialize the database schema.+++
|`+classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.sql+`

|[[application-properties.core.spring.quartz.job-store-type]]xref:#application-properties.core.spring.quartz.job-store-type[`+spring.quartz.job-store-type+`]
|+++Quartz job store type.+++
|`+memory+`

|[[application-properties.core.spring.quartz.overwrite-existing-jobs]]xref:#application-properties.core.spring.quartz.overwrite-existing-jobs[`+spring.quartz.overwrite-existing-jobs+`]
|+++Whether configured jobs should overwrite existing job definitions.+++
|`+false+`

|[[application-properties.core.spring.quartz.properties]]xref:#application-properties.core.spring.quartz.properties[`+spring.quartz.properties.*+`]
|+++Additional Quartz Scheduler properties.+++
|

|[[application-properties.core.spring.quartz.scheduler-name]]xref:#application-properties.core.spring.quartz.scheduler-name[`+spring.quartz.scheduler-name+`]
|+++Name of the scheduler.+++
|`+quartzScheduler+`

|[[application-properties.core.spring.quartz.startup-delay]]xref:#application-properties.core.spring.quartz.startup-delay[`+spring.quartz.startup-delay+`]
|+++Delay after which the scheduler is started once initialization completes. Setting this property makes sense if no jobs should be run before the entire application has started up.+++
|`+0s+`

|[[application-properties.core.spring.quartz.wait-for-jobs-to-complete-on-shutdown]]xref:#application-properties.core.spring.quartz.wait-for-jobs-to-complete-on-shutdown[`+spring.quartz.wait-for-jobs-to-complete-on-shutdown+`]
|+++Whether to wait for running jobs to complete on shutdown.+++
|`+false+`

|[[application-properties.core.spring.reactor.context-propagation]]xref:#application-properties.core.spring.reactor.context-propagation[`+spring.reactor.context-propagation+`]
|+++Context Propagation support mode for Reactor operators.+++
|`+limited+`

|[[application-properties.core.spring.reactor.debug-agent.enabled]]xref:#application-properties.core.spring.reactor.debug-agent.enabled[`+spring.reactor.debug-agent.enabled+`]
|+++Whether the Reactor Debug Agent should be enabled when reactor-tools is present.+++
|`+true+`

|[[application-properties.core.spring.reactor.netty.shutdown-quiet-period]]xref:#application-properties.core.spring.reactor.netty.shutdown-quiet-period[`+spring.reactor.netty.shutdown-quiet-period+`]
|+++Amount of time to wait before shutting down resources.+++
|

|[[application-properties.core.spring.ssl.bundle.jks]]xref:#application-properties.core.spring.ssl.bundle.jks[`+spring.ssl.bundle.jks.*+`]
|+++Java keystore SSL trust material.+++
|

|[[application-properties.core.spring.ssl.bundle.pem]]xref:#application-properties.core.spring.ssl.bundle.pem[`+spring.ssl.bundle.pem.*+`]
|+++PEM-encoded SSL trust material.+++
|

|[[application-properties.core.spring.ssl.bundle.watch.file.quiet-period]]xref:#application-properties.core.spring.ssl.bundle.watch.file.quiet-period[`+spring.ssl.bundle.watch.file.quiet-period+`]
|+++Quiet period, after which changes are detected.+++
|`+10s+`

|[[application-properties.core.spring.task.execution.pool.allow-core-thread-timeout]]xref:#application-properties.core.spring.task.execution.pool.allow-core-thread-timeout[`+spring.task.execution.pool.allow-core-thread-timeout+`]
|+++Whether core threads are allowed to time out. This enables dynamic growing and shrinking of the pool.+++
|`+true+`

|[[application-properties.core.spring.task.execution.pool.core-size]]xref:#application-properties.core.spring.task.execution.pool.core-size[`+spring.task.execution.pool.core-size+`]
|+++Core number of threads.+++
|`+8+`

|[[application-properties.core.spring.task.execution.pool.keep-alive]]xref:#application-properties.core.spring.task.execution.pool.keep-alive[`+spring.task.execution.pool.keep-alive+`]
|+++Time limit for which threads may remain idle before being terminated.+++
|`+60s+`

|[[application-properties.core.spring.task.execution.pool.max-size]]xref:#application-properties.core.spring.task.execution.pool.max-size[`+spring.task.execution.pool.max-size+`]
|+++Maximum allowed number of threads. If tasks are filling up the queue, the pool can expand up to that size to accommodate the load. Ignored if the queue is unbounded.+++
|

|[[application-properties.core.spring.task.execution.pool.queue-capacity]]xref:#application-properties.core.spring.task.execution.pool.queue-capacity[`+spring.task.execution.pool.queue-capacity+`]
|+++Queue capacity. An unbounded capacity does not increase the pool and therefore ignores the "max-size" property.+++
|

|[[application-properties.core.spring.task.execution.pool.shutdown.accept-tasks-after-context-close]]xref:#application-properties.core.spring.task.execution.pool.shutdown.accept-tasks-after-context-close[`+spring.task.execution.pool.shutdown.accept-tasks-after-context-close+`]
|+++Whether to accept further tasks after the application context close phase has begun.+++
|`+false+`

|[[application-properties.core.spring.task.execution.shutdown.await-termination]]xref:#application-properties.core.spring.task.execution.shutdown.await-termination[`+spring.task.execution.shutdown.await-termination+`]
|+++Whether the executor should wait for scheduled tasks to complete on shutdown.+++
|`+false+`

|[[application-properties.core.spring.task.execution.shutdown.await-termination-period]]xref:#application-properties.core.spring.task.execution.shutdown.await-termination-period[`+spring.task.execution.shutdown.await-termination-period+`]
|+++Maximum time the executor should wait for remaining tasks to complete.+++
|

|[[application-properties.core.spring.task.execution.simple.concurrency-limit]]xref:#application-properties.core.spring.task.execution.simple.concurrency-limit[`+spring.task.execution.simple.concurrency-limit+`]
|+++Set the maximum number of parallel accesses allowed. -1 indicates no concurrency limit at all.+++
|

|[[application-properties.core.spring.task.execution.thread-name-prefix]]xref:#application-properties.core.spring.task.execution.thread-name-prefix[`+spring.task.execution.thread-name-prefix+`]
|+++Prefix to use for the names of newly created threads.+++
|`+task-+`

|[[application-properties.core.spring.task.scheduling.pool.size]]xref:#application-properties.core.spring.task.scheduling.pool.size[`+spring.task.scheduling.pool.size+`]
|+++Maximum allowed number of threads.+++
|`+1+`

|[[application-properties.core.spring.task.scheduling.shutdown.await-termination]]xref:#application-properties.core.spring.task.scheduling.shutdown.await-termination[`+spring.task.scheduling.shutdown.await-termination+`]
|+++Whether the executor should wait for scheduled tasks to complete on shutdown.+++
|`+false+`

|[[application-properties.core.spring.task.scheduling.shutdown.await-termination-period]]xref:#application-properties.core.spring.task.scheduling.shutdown.await-termination-period[`+spring.task.scheduling.shutdown.await-termination-period+`]
|+++Maximum time the executor should wait for remaining tasks to complete.+++
|

|[[application-properties.core.spring.task.scheduling.simple.concurrency-limit]]xref:#application-properties.core.spring.task.scheduling.simple.concurrency-limit[`+spring.task.scheduling.simple.concurrency-limit+`]
|+++Set the maximum number of parallel accesses allowed. -1 indicates no concurrency limit at all.+++
|

|[[application-properties.core.spring.task.scheduling.thread-name-prefix]]xref:#application-properties.core.spring.task.scheduling.thread-name-prefix[`+spring.task.scheduling.thread-name-prefix+`]
|+++Prefix to use for the names of newly created threads.+++
|`+scheduling-+`

|[[application-properties.core.spring.threads.virtual.enabled]]xref:#application-properties.core.spring.threads.virtual.enabled[`+spring.threads.virtual.enabled+`]
|+++Whether to use virtual threads.+++
|`+false+`

|[[application-properties.core.trace]]xref:#application-properties.core.trace[`+trace+`]
|+++Enable trace logs.+++
|`+false+`

|===
