Auto-configure SimpleAsyncTaskScheduler when virtual threads are enabled

This auto-configures a new SimpleAsyncTaskSchedulerBuilder bean in the
context. This bean is configured to use virtual threads, if enabled.

SimpleAsyncTaskSchedulerCustomizers can be used to customize the built
SimpleAsyncTaskScheduler.

If virtual threads are enabled, the application task scheduler is
configured to be a SimpleAsyncTaskScheduler.

Adds a new configuration property spring.task.scheduling.simple
.concurrency-limit

Closes gh-36609

Author: mhalbritter

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/task/TaskSchedulingAutoConfiguration.java

@@ -40,7 +40,8 @@
 @EnableConfigurationProperties(TaskSchedulingProperties.class)
 @Import({ TaskSchedulingConfigurations.ThreadPoolTaskSchedulerBuilderConfiguration.class,
 		TaskSchedulingConfigurations.TaskSchedulerBuilderConfiguration.class,
-		TaskSchedulingConfigurations.ThreadPoolTaskSchedulerConfiguration.class })
+		TaskSchedulingConfigurations.SimpleAsyncTaskSchedulerBuilderConfiguration.class,
+		TaskSchedulingConfigurations.TaskSchedulerConfiguration.class })
 public class TaskSchedulingAutoConfiguration {
 
 	@Bean

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/task/TaskSchedulingConfigurations.java

@@ -21,13 +21,18 @@
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnThreading;
+import org.springframework.boot.autoconfigure.thread.Threading;
+import org.springframework.boot.task.SimpleAsyncTaskSchedulerBuilder;
+import org.springframework.boot.task.SimpleAsyncTaskSchedulerCustomizer;
 import org.springframework.boot.task.TaskSchedulerBuilder;
 import org.springframework.boot.task.TaskSchedulerCustomizer;
 import org.springframework.boot.task.ThreadPoolTaskSchedulerBuilder;
 import org.springframework.boot.task.ThreadPoolTaskSchedulerCustomizer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.scheduling.TaskScheduler;
+import org.springframework.scheduling.concurrent.SimpleAsyncTaskScheduler;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
 import org.springframework.scheduling.config.TaskManagementConfigUtils;
 
@@ -43,9 +48,16 @@ class TaskSchedulingConfigurations {
 	@ConditionalOnBean(name = TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)
 	@ConditionalOnMissingBean({ TaskScheduler.class, ScheduledExecutorService.class })
 	@SuppressWarnings("removal")
-	static class ThreadPoolTaskSchedulerConfiguration {
+	static class TaskSchedulerConfiguration {
+
+		@Bean(name = "taskScheduler")
+		@ConditionalOnThreading(Threading.VIRTUAL)
+		SimpleAsyncTaskScheduler taskSchedulerVirtualThreads(SimpleAsyncTaskSchedulerBuilder builder) {
+			return builder.build();
+		}
 
 		@Bean
+		@ConditionalOnThreading(Threading.PLATFORM)
 		ThreadPoolTaskScheduler taskScheduler(TaskSchedulerBuilder taskSchedulerBuilder,
 				ObjectProvider<ThreadPoolTaskSchedulerBuilder> threadPoolTaskSchedulerBuilderProvider) {
 			ThreadPoolTaskSchedulerBuilder threadPoolTaskSchedulerBuilder = threadPoolTaskSchedulerBuilderProvider
@@ -105,4 +117,44 @@ private ThreadPoolTaskSchedulerCustomizer adapt(TaskSchedulerCustomizer customiz
 
 	}
 
+	@Configuration(proxyBeanMethods = false)
+	static class SimpleAsyncTaskSchedulerBuilderConfiguration {
+
+		private final TaskSchedulingProperties properties;
+
+		private final ObjectProvider<SimpleAsyncTaskSchedulerCustomizer> taskSchedulerCustomizers;
+
+		SimpleAsyncTaskSchedulerBuilderConfiguration(TaskSchedulingProperties properties,
+				ObjectProvider<SimpleAsyncTaskSchedulerCustomizer> taskSchedulerCustomizers) {
+			this.properties = properties;
+			this.taskSchedulerCustomizers = taskSchedulerCustomizers;
+		}
+
+		@Bean
+		@ConditionalOnMissingBean
+		@ConditionalOnThreading(Threading.PLATFORM)
+		SimpleAsyncTaskSchedulerBuilder simpleAsyncTaskSchedulerBuilder() {
+			return builder();
+		}
+
+		@Bean(name = "simpleAsyncTaskSchedulerBuilder")
+		@ConditionalOnMissingBean
+		@ConditionalOnThreading(Threading.VIRTUAL)
+		SimpleAsyncTaskSchedulerBuilder simpleAsyncTaskSchedulerBuilderVirtualThreads() {
+			SimpleAsyncTaskSchedulerBuilder builder = builder();
+			builder = builder.virtualThreads(true);
+			return builder;
+		}
+
+		private SimpleAsyncTaskSchedulerBuilder builder() {
+			SimpleAsyncTaskSchedulerBuilder builder = new SimpleAsyncTaskSchedulerBuilder();
+			builder = builder.threadNamePrefix(this.properties.getThreadNamePrefix());
+			builder = builder.customizers(this.taskSchedulerCustomizers.orderedStream()::iterator);
+			TaskSchedulingProperties.Simple simple = this.properties.getSimple();
+			builder = builder.concurrencyLimit(simple.getConcurrencyLimit());
+			return builder;
+		}
+
+	}
+
 }

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/task/TaskSchedulingProperties.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2023 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,6 +31,8 @@ public class TaskSchedulingProperties {
 
 	private final Pool pool = new Pool();
 
+	private final Simple simple = new Simple();
+
 	private final Shutdown shutdown = new Shutdown();
 
 	/**
@@ -42,6 +44,10 @@ public Pool getPool() {
 		return this.pool;
 	}
 
+	public Simple getSimple() {
+		return this.simple;
+	}
+
 	public Shutdown getShutdown() {
 		return this.shutdown;
 	}
@@ -71,6 +77,24 @@ public void setSize(int size) {
 
 	}
 
+	public static class Simple {
+
+		/**
+		 * Set the maximum number of parallel accesses allowed. -1 indicates no
+		 * concurrency limit at all.
+		 */
+		private Integer concurrencyLimit;
+
+		public Integer getConcurrencyLimit() {
+			return this.concurrencyLimit;
+		}
+
+		public void setConcurrencyLimit(Integer concurrencyLimit) {
+			this.concurrencyLimit = concurrencyLimit;
+		}
+
+	}
+
 	public static class Shutdown {
 
 		/**

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/task/TaskSchedulingAutoConfigurationTests.java

@@ -28,9 +28,13 @@
 
 import org.awaitility.Awaitility;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledForJreRange;
+import org.junit.jupiter.api.condition.JRE;
 
 import org.springframework.boot.LazyInitializationBeanFactoryPostProcessor;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.task.SimpleAsyncTaskSchedulerBuilder;
+import org.springframework.boot.task.SimpleAsyncTaskSchedulerCustomizer;
 import org.springframework.boot.task.TaskSchedulerBuilder;
 import org.springframework.boot.task.TaskSchedulerCustomizer;
 import org.springframework.boot.task.ThreadPoolTaskSchedulerBuilder;
@@ -45,6 +49,7 @@
 import org.springframework.scheduling.annotation.SchedulingConfigurer;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
 import org.springframework.scheduling.config.ScheduledTaskRegistrar;
+import org.springframework.test.util.ReflectionTestUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -110,6 +115,58 @@ void enableSchedulingWithNoTaskExecutorAutoConfiguresOne() {
 			});
 	}
 
+	@Test
+	void simpleAsyncTaskSchedulerBuilderShouldReadProperties() {
+		this.contextRunner
+			.withPropertyValues("spring.task.scheduling.simple.concurrency-limit=1",
+					"spring.task.scheduling.thread-name-prefix=scheduling-test-")
+			.withUserConfiguration(SchedulingConfiguration.class)
+			.run((context) -> {
+				assertThat(context).hasSingleBean(SimpleAsyncTaskSchedulerBuilder.class);
+				SimpleAsyncTaskSchedulerBuilder builder = context.getBean(SimpleAsyncTaskSchedulerBuilder.class);
+				assertThat(builder).hasFieldOrPropertyWithValue("threadNamePrefix", "scheduling-test-");
+				assertThat(builder).hasFieldOrPropertyWithValue("concurrencyLimit", 1);
+			});
+	}
+
+	@Test
+	@EnabledForJreRange(min = JRE.JAVA_21)
+	void simpleAsyncTaskSchedulerBuilderShouldUseVirtualThreadsIfEnabled() {
+		this.contextRunner.withPropertyValues("spring.threads.virtual.enabled=true")
+			.withUserConfiguration(SchedulingConfiguration.class)
+			.run((context) -> {
+				assertThat(context).hasSingleBean(SimpleAsyncTaskSchedulerBuilder.class);
+				SimpleAsyncTaskSchedulerBuilder builder = context.getBean(SimpleAsyncTaskSchedulerBuilder.class);
+				assertThat(builder).hasFieldOrPropertyWithValue("virtualThreads", true);
+			});
+	}
+
+	@Test
+	@EnabledForJreRange(min = JRE.JAVA_21)
+	void simpleAsyncTaskSchedulerBuilderShouldUsePlatformThreadsByDefault() {
+		this.contextRunner.withUserConfiguration(SchedulingConfiguration.class).run((context) -> {
+			assertThat(context).hasSingleBean(SimpleAsyncTaskSchedulerBuilder.class);
+			SimpleAsyncTaskSchedulerBuilder builder = context.getBean(SimpleAsyncTaskSchedulerBuilder.class);
+			assertThat(builder).hasFieldOrPropertyWithValue("virtualThreads", null);
+		});
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	void simpleAsyncTaskSchedulerBuilderShouldApplyCustomizers() {
+		SimpleAsyncTaskSchedulerCustomizer customizer = (scheduler) -> {
+		};
+		this.contextRunner.withBean(SimpleAsyncTaskSchedulerCustomizer.class, () -> customizer)
+			.withUserConfiguration(SchedulingConfiguration.class)
+			.run((context) -> {
+				assertThat(context).hasSingleBean(SimpleAsyncTaskSchedulerBuilder.class);
+				SimpleAsyncTaskSchedulerBuilder builder = context.getBean(SimpleAsyncTaskSchedulerBuilder.class);
+				Set<SimpleAsyncTaskSchedulerCustomizer> customizers = (Set<SimpleAsyncTaskSchedulerCustomizer>) ReflectionTestUtils
+					.getField(builder, "customizers");
+				assertThat(customizers).as("SimpleAsyncTaskSchedulerBuilder.customizers").contains(customizer);
+			});
+	}
+
 	@Test
 	void enableSchedulingWithNoTaskExecutorAppliesTaskSchedulerCustomizers() {
 		this.contextRunner.withPropertyValues("spring.task.scheduling.thread-name-prefix=scheduling-test-")

spring-boot-project/spring-boot-docs/src/docs/asciidoc/features/task-execution-and-scheduling.adoc

@@ -36,8 +36,11 @@ Those default settings can be fine-tuned using the `spring.task.execution` names
 This changes the thread pool to use a bounded queue so that when the queue is full (100 tasks), the thread pool increases to maximum 16 threads.
 Shrinking of the pool is more aggressive as threads are reclaimed when they are idle for 10 seconds (rather than 60 seconds by default).
 
-A `ThreadPoolTaskScheduler` can also be auto-configured if need to be associated to scheduled task execution (using `@EnableScheduling` for instance).
-The thread pool uses one thread by default and its settings can be fine-tuned using the `spring.task.scheduling` namespace, as shown in the following example:
+A scheduler can also be auto-configured if need to be associated to scheduled task execution (using `@EnableScheduling` for instance).
+When virtual threads are enabled (using Java 21+ and configprop:spring.threads.virtual.enabled[] set to `true`) this will be a `SimpleAsyncTaskScheduler` that uses virtual threads.
+Otherwise, it will be a `ThreadPoolTaskScheduler` with sensible defaults.
+
+The `ThreadPoolTaskScheduler` uses one thread by default and its settings can be fine-tuned using the `spring.task.scheduling` namespace, as shown in the following example:
 
 [source,yaml,indent=0,subs="verbatim",configprops,configblocks]
 ----
@@ -49,5 +52,5 @@ The thread pool uses one thread by default and its settings can be fine-tuned us
 	        size: 2
 ----
 
-A `ThreadPoolTaskExecutorBuilder` bean, a `SimpleAsyncTaskExecutorBuilder` bean and a `ThreadPoolTaskSchedulerBuilder` bean are made available in the context if a custom executor or scheduler needs to be created.
-The `SimpleAsyncTaskExecutorBuilder` is auto-configured to use virtual threads if they are enabled (using Java 21+ and configprop:spring.threads.virtual.enabled[] set to `true`).
+A `ThreadPoolTaskExecutorBuilder` bean, a `SimpleAsyncTaskExecutorBuilder` bean, a `ThreadPoolTaskSchedulerBuilder` bean and a `SimpleAsyncTaskSchedulerBuilder` are made available in the context if a custom executor or scheduler needs to be created.
+The `SimpleAsyncTaskExecutorBuilder` and `SimpleAsyncTaskSchedulerBuilder` beans are auto-configured to use virtual threads if they are enabled (using Java 21+ and configprop:spring.threads.virtual.enabled[] set to `true`).