org.springframework.scheduling.concurrent.ConcurrentTaskScheduler Java Examples

@BeforeEach
void setUp() {
    final MeterRegistry meterRegistry = new SimpleMeterRegistry();
    final ScriptManagerProperties scriptManagerProperties = new ScriptManagerProperties();
    final TaskScheduler taskScheduler = new ConcurrentTaskScheduler();
    final ExecutorService executorService = Executors.newCachedThreadPool();
    final ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    final ResourceLoader resourceLoader = new DefaultResourceLoader();
    final ScriptManager scriptManager = new ScriptManager(
        scriptManagerProperties,
        taskScheduler,
        executorService,
        scriptEngineManager,
        resourceLoader,
        meterRegistry
    );
    this.scriptProperties = new ClusterSelectorScriptProperties();
    this.clusterSelectorScript = new ClusterSelectorManagedScript(
        scriptManager,
        this.scriptProperties,
        meterRegistry
    );
}
 

@BeforeEach
void setUp() {
    final MeterRegistry meterRegistry = new SimpleMeterRegistry();
    final ScriptManagerProperties scriptManagerProperties = new ScriptManagerProperties();
    final TaskScheduler taskScheduler = new ConcurrentTaskScheduler();
    final ExecutorService executorService = Executors.newCachedThreadPool();
    final ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    final ResourceLoader resourceLoader = new DefaultResourceLoader();
    this.objectMapper = GenieObjectMapper.getMapper();
    final ScriptManager scriptManager = new ScriptManager(
        scriptManagerProperties,
        taskScheduler,
        executorService,
        scriptEngineManager,
        resourceLoader,
        meterRegistry
    );
    this.scriptProperties = new TestScriptProperties();
    this.script = new TestScript(
        scriptManager,
        this.scriptProperties,
        meterRegistry
    );
}
 

@BeforeEach
void setUp() {
    final MeterRegistry meterRegistry = new SimpleMeterRegistry();
    final ScriptManagerProperties scriptManagerProperties = new ScriptManagerProperties();
    final TaskScheduler taskScheduler = new ConcurrentTaskScheduler();
    final ExecutorService executorService = Executors.newCachedThreadPool();
    final ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    final ResourceLoader resourceLoader = new DefaultResourceLoader();
    final ObjectMapper objectMapper = GenieObjectMapper.getMapper();
    final ScriptManager scriptManager = new ScriptManager(
        scriptManagerProperties,
        taskScheduler,
        executorService,
        scriptEngineManager,
        resourceLoader,
        meterRegistry
    );
    this.scriptProperties = new ExecutionModeFilterScriptProperties();
    this.executionModeFilterScript = new ExecutionModeFilterScript(
        scriptManager,
        scriptProperties,
        objectMapper,
        meterRegistry
    );
}
 

public static void main(String... argv) {
    WebSocketClient webSocketClient = new StandardWebSocketClient();
    WebSocketStompClient stompClient = new WebSocketStompClient(webSocketClient);
    stompClient.setMessageConverter(new MappingJackson2MessageConverter());
    stompClient.setTaskScheduler(new ConcurrentTaskScheduler());

    String url = "ws://127.0.0.1:8080/hello";
    StompSessionHandler sessionHandler = new MySessionHandler();
    stompClient.connect(url, sessionHandler);

    new Scanner(System.in).nextLine(); //Don't close immediately.
}
 

@BeforeEach
void setUp() {
    this.meterRegistry = new SimpleMeterRegistry();
    this.executorService = Executors.newCachedThreadPool();
    final ScriptManager scriptManager = new ScriptManager(
        new ScriptManagerProperties(),
        new ConcurrentTaskScheduler(),
        this.executorService,
        new ScriptEngineManager(),
        new DefaultResourceLoader(),
        this.meterRegistry
    );
    this.scriptProperties = new CommandSelectorManagedScriptProperties();
    this.commandSelectorManagedScript = new CommandSelectorManagedScript(
        scriptManager,
        this.scriptProperties,
        this.meterRegistry
    );
}
 

@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
    if (properties.isEnabled()) {
        TaskScheduler taskScheduler = null;
        try {
            taskScheduler = this.beanFactory.getBean(TaskScheduler.class);
        } catch (NoUniqueBeanDefinitionException e) {
            taskScheduler = this.beanFactory.getBean("taskScheduler", TaskScheduler.class);
        } catch (NoSuchBeanDefinitionException ex) {
            log.warn("'useExistingScheduler' was configured to 'true', but we did not find any bean.");
        }
        if (taskScheduler != null) {
            log.info("register existing TaskScheduler");
            taskRegistrar.setScheduler(taskScheduler);
        } else {
            throw new BeanCreationException("Expecting a 'ConcurrentTaskScheduler' injected, but was 'null'");
        }
    } else {
        log.info("'CustomSchedulingConfiguration' is disabled, create a default - 'ConcurrentTaskScheduler'");
        this.localExecutor = Executors.newSingleThreadScheduledExecutor();
        taskRegistrar.setScheduler(new ConcurrentTaskScheduler(localExecutor));
    }
}
 

@Override
public void postProcessBeanDefinitionRegistry(@NonNull BeanDefinitionRegistry registry) throws BeansException {
    ListableBeanFactory listableBeanFactory = (ListableBeanFactory) this.beanFactory;
    if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(listableBeanFactory, TaskScheduler.class).length == 0) {
        String[] scheduledExecutorsBeanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(listableBeanFactory, ScheduledExecutorService.class);
        if (scheduledExecutorsBeanNames.length != 1) {
            logger.debug("Registering default TaskScheduler");
            registry.registerBeanDefinition(DEFAULT_TASK_SCHEDULER_BEAN_NAME, rootBeanDefinition(ConcurrentTaskScheduler.class).getBeanDefinition());
            if (scheduledExecutorsBeanNames.length != 0) {
                logger.warn("Multiple ScheduledExecutorService found, do not know which one to use.");
            }
        } else {
            logger.debug("Registering default TaskScheduler with existing ScheduledExecutorService {}", scheduledExecutorsBeanNames[0]);
            registry.registerBeanDefinition(DEFAULT_TASK_SCHEDULER_BEAN_NAME,
                rootBeanDefinition(ConcurrentTaskScheduler.class)
                    .addPropertyReference("scheduledExecutor", scheduledExecutorsBeanNames[0])
                    .getBeanDefinition()
            );
        }
    }
}
 

/**
 * Set the {@link TaskScheduler} to register scheduled tasks with, or a
 * {@link java.util.concurrent.ScheduledExecutorService} to be wrapped as a
 * {@code TaskScheduler}.
 */
public void setScheduler(@Nullable Object scheduler) {
	if (scheduler == null) {
		this.taskScheduler = null;
	}
	else if (scheduler instanceof TaskScheduler) {
		this.taskScheduler = (TaskScheduler) scheduler;
	}
	else if (scheduler instanceof ScheduledExecutorService) {
		this.taskScheduler = new ConcurrentTaskScheduler(((ScheduledExecutorService) scheduler));
	}
	else {
		throw new IllegalArgumentException("Unsupported scheduler type: " + scheduler.getClass());
	}
}
 

@Test
public void findExecutorByName() throws NoSuchFieldException, IllegalAccessException {
    ScheduledExecutorService expected = Executors.newScheduledThreadPool(4);
    Throwable exc = new NoUniqueBeanDefinitionException(ScheduledExecutorService.class);
    when(context.getBean(ScheduledExecutorService.class)).thenThrow(exc);
    when(context.getBean("taskScheduler", ScheduledExecutorService.class))
            .thenReturn(expected);

    configuration.configureTasks(registrar);
    TaskScheduler scheduler = registrar.getScheduler();
    assertTrue(scheduler instanceof ConcurrentTaskScheduler);
    assertEquals(expected, accessField(scheduler, "scheduledExecutor"));
}
 

@Test
public void findExecutorByType() throws NoSuchFieldException, IllegalAccessException {
    ScheduledExecutorService expected = Executors.newScheduledThreadPool(1);
    when(context.getBean(ScheduledExecutorService.class)).thenReturn(expected);

    configuration.configureTasks(registrar);
    TaskScheduler scheduler = registrar.getScheduler();
    assertTrue(scheduler instanceof ConcurrentTaskScheduler);
    assertEquals(expected, accessField(scheduler, "scheduledExecutor"));
}
 

@Bean(name = DEFAULT_TASK_SCHEDULER_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TaskScheduler taskScheduler() {
    if (taskExecutor != null) {
        log.debug("create task-scheduler with pre-configured executor ...");
        return new ConcurrentTaskScheduler(taskExecutor, scheduledExecutorService());
    } else {
        log.debug("create task-scheduler without pre-configured executor ...");
        return new ConcurrentTaskScheduler(scheduledExecutorService());
    }
}
 

/**
 * Set the {@link TaskScheduler} to register scheduled tasks with, or a
 * {@link java.util.concurrent.ScheduledExecutorService} to be wrapped as a
 * {@code TaskScheduler}.
 */
public void setScheduler(Object scheduler) {
	Assert.notNull(scheduler, "Scheduler object must not be null");
	if (scheduler instanceof TaskScheduler) {
		this.taskScheduler = (TaskScheduler) scheduler;
	}
	else if (scheduler instanceof ScheduledExecutorService) {
		this.taskScheduler = new ConcurrentTaskScheduler(((ScheduledExecutorService) scheduler));
	}
	else {
		throw new IllegalArgumentException("Unsupported scheduler type: " + scheduler.getClass());
	}
}
 

/**
 * Set the {@link TaskScheduler} to register scheduled tasks with, or a
 * {@link java.util.concurrent.ScheduledExecutorService} to be wrapped as a
 * {@code TaskScheduler}.
 */
public void setScheduler(Object scheduler) {
	Assert.notNull(scheduler, "Scheduler object must not be null");
	if (scheduler instanceof TaskScheduler) {
		this.taskScheduler = (TaskScheduler) scheduler;
	}
	else if (scheduler instanceof ScheduledExecutorService) {
		this.taskScheduler = new ConcurrentTaskScheduler(((ScheduledExecutorService) scheduler));
	}
	else {
		throw new IllegalArgumentException("Unsupported scheduler type: " + scheduler.getClass());
	}
}
 

/**
 * Set the {@link TaskScheduler} to register scheduled tasks with, or a
 * {@link java.util.concurrent.ScheduledExecutorService} to be wrapped as a
 * {@code TaskScheduler}.
 */
public void setScheduler(@Nullable Object scheduler) {
	if (scheduler == null) {
		this.taskScheduler = null;
	}
	else if (scheduler instanceof TaskScheduler) {
		this.taskScheduler = (TaskScheduler) scheduler;
	}
	else if (scheduler instanceof ScheduledExecutorService) {
		this.taskScheduler = new ConcurrentTaskScheduler(((ScheduledExecutorService) scheduler));
	}
	else {
		throw new IllegalArgumentException("Unsupported scheduler type: " + scheduler.getClass());
	}
}
 

public LightminClientApplicationRegistrationService(final LightminClientRegistratorService lightminClientRegistrator,
                                                    final ScheduledExecutorService scheduler) {
    this(lightminClientRegistrator, new ConcurrentTaskScheduler(scheduler));
}
 

/**
 * @return {@link TaskScheduler} for task execution
 */
@Bean
@ConditionalOnMissingBean
public TaskScheduler taskScheduler() {
    return new ConcurrentTaskScheduler(scheduledExecutorService());
}
 

@Bean
TaskScheduler taskScheduler() {
    return new ConcurrentTaskScheduler(threadPool());
}
 

@Bean
TaskScheduler taskScheduler() {
  return new ConcurrentTaskScheduler(Executors.newSingleThreadScheduledExecutor());
}
 

@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
	taskRegistrar.setTaskScheduler(new ConcurrentTaskScheduler(
			Executors.newSingleThreadScheduledExecutor()));
}
 

@Bean
public TaskScheduler taskScheduler() {
    return new ConcurrentTaskScheduler();
}
 

@Bean
public TaskScheduler taskScheduler() {
    return new ConcurrentTaskScheduler(Executors.newSingleThreadScheduledExecutor());
}