Java TaskScheduler类代码示例

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Test
public void postProcessAfterInitialization() throws Exception {
    assertThat(processor.postProcessAfterInitialization(mock(Executor.class), toBeExcluded).getClass(),
            not(equalTo(ContextAwareExecutor.class)));
    //concurrent
    assertThat(processor.postProcessAfterInitialization(mock(Executor.class), beanName).getClass(),
            equalTo(ContextAwareExecutor.class));
    assertThat(processor.postProcessAfterInitialization(mock(ExecutorService.class), beanName).getClass(),
            equalTo(ContextAwareExecutorService.class));
    assertThat(processor.postProcessAfterInitialization(mock(ScheduledExecutorService.class), beanName).getClass(),
            equalTo(ContextAwareScheduledExecutorService.class));

    //spring
    assertThat(processor.postProcessAfterInitialization(mock(TaskScheduler.class), beanName).getClass(),
            equalTo(ContextAwareTaskScheduler.class));
    assertThat(processor.postProcessAfterInitialization(new ThreadPoolTaskExecutor(), beanName).getClass(),
            equalTo(ContextAwareThreadPoolTaskExecutor.class));
    assertThat(processor.postProcessAfterInitialization(new ThreadPoolTaskScheduler(), beanName).getClass(),
            equalTo(ContextAwareThreadPoolTaskScheduler.class));
    assertThat(processor.postProcessAfterInitialization(mock(AsyncListenableTaskExecutor.class), beanName).getClass(),
            equalTo(ContextAwareAsyncListenableTaskExecutor.class));
    assertThat(processor.postProcessAfterInitialization(mock(AsyncTaskExecutor.class), beanName).getClass(),
            equalTo(ContextAwareAsyncTaskExecutor.class));
    assertThat(processor.postProcessAfterInitialization(mock(SchedulingTaskExecutor.class), beanName).getClass(),
            equalTo(ContextAwareSchedulingTaskExecutor.class));
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Bean
public TaskScheduler bbTaskScheduler() {
	ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
	taskScheduler.setThreadNamePrefix("API-Schd-ThrP-");
	taskScheduler.setAwaitTerminationSeconds(1);
	taskScheduler.setRejectedExecutionHandler(new ThreadPoolTaskRejectedHandler());
	
	return taskScheduler;
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Test
public void sendWithReceipt() throws Exception {

	this.session.afterConnected(this.connection);
	assertTrue(this.session.isConnected());

	this.session.setTaskScheduler(mock(TaskScheduler.class));
	this.session.setAutoReceipt(true);
	this.session.send("/topic/foo", "sample payload");

	Message<byte[]> message = this.messageCaptor.getValue();
	StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	assertNotNull(accessor.getReceipt());

	StompHeaders stompHeaders = new StompHeaders();
	stompHeaders.setDestination("/topic/foo");
	stompHeaders.setReceipt("my-receipt");
	this.session.send(stompHeaders, "sample payload");

	message = this.messageCaptor.getValue();
	accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	assertEquals("my-receipt", accessor.getReceipt());
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Test
public void receiptReceived() throws Exception {

	this.session.afterConnected(this.connection);
	this.session.setTaskScheduler(mock(TaskScheduler.class));

	AtomicReference<Boolean> received = new AtomicReference<>();

	StompHeaders headers = new StompHeaders();
	headers.setDestination("/topic/foo");
	headers.setReceipt("my-receipt");
	Subscription subscription = this.session.subscribe(headers, mock(StompFrameHandler.class));
	subscription.addReceiptTask(() -> received.set(true));

	assertNull(received.get());

	StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.RECEIPT);
	accessor.setReceiptId("my-receipt");
	accessor.setLeaveMutable(true);
	this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders()));

	assertNotNull(received.get());
	assertTrue(received.get());
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Test
public void receiptReceivedBeforeTaskAdded() throws Exception {

	this.session.afterConnected(this.connection);
	this.session.setTaskScheduler(mock(TaskScheduler.class));

	AtomicReference<Boolean> received = new AtomicReference<>();

	StompHeaders headers = new StompHeaders();
	headers.setDestination("/topic/foo");
	headers.setReceipt("my-receipt");
	Subscription subscription = this.session.subscribe(headers, mock(StompFrameHandler.class));

	StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.RECEIPT);
	accessor.setReceiptId("my-receipt");
	accessor.setLeaveMutable(true);
	this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders()));

	subscription.addReceiptTask(() -> received.set(true));

	assertNotNull(received.get());
	assertTrue(received.get());
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
/**
 * Create a TransportHandlingSockJsService with given {@link TransportHandler handler} types.
 * @param scheduler a task scheduler for heart-beat messages and removing timed-out sessions;
 * the provided TaskScheduler should be declared as a Spring bean to ensure it gets
 * initialized at start-up and shuts down when the application stops
 * @param handlers one or more {@link TransportHandler} implementations to use
 */
public TransportHandlingSockJsService(TaskScheduler scheduler, Collection<TransportHandler> handlers) {
	super(scheduler);

	if (CollectionUtils.isEmpty(handlers)) {
		logger.warn("No transport handlers specified for TransportHandlingSockJsService");
	}
	else {
		for (TransportHandler handler : handlers) {
			handler.initialize(this);
			this.handlers.put(handler.getTransportType(), handler);
		}
	}

	if (jackson2Present) {
		this.messageCodec = new Jackson2SockJsMessageCodec();
	}
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Test
public void fallbackAfterTimeout() throws Exception {
	TaskScheduler scheduler = mock(TaskScheduler.class);
	Runnable sessionCleanupTask = mock(Runnable.class);
	DefaultTransportRequest request1 = createTransportRequest(this.webSocketTransport, TransportType.WEBSOCKET);
	DefaultTransportRequest request2 = createTransportRequest(this.xhrTransport, TransportType.XHR_STREAMING);
	request1.setFallbackRequest(request2);
	request1.setTimeoutScheduler(scheduler);
	request1.addTimeoutTask(sessionCleanupTask);
	request1.connect(null, this.connectFuture);

	assertTrue(this.webSocketTransport.invoked());
	assertFalse(this.xhrTransport.invoked());

	// Get and invoke the scheduled timeout task
	ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClass(Runnable.class);
	verify(scheduler).schedule(taskCaptor.capture(), any(Date.class));
	verifyNoMoreInteractions(scheduler);
	taskCaptor.getValue().run();

	assertTrue(this.xhrTransport.invoked());
	verify(sessionCleanupTask).run();
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
private void doTestWrapperTokenCreated(String authMountPath) {
    final ClientHttpRequestFactory factory = createClientHttpRequestFactory();
    final VaultTemplate template = new VaultTemplate(getVault().getEndpoint(), factory, () -> VaultToken.of(getVault().getToken()));

    // Ensure approle auth enabled
    template.opsForSys().authMount(authMountPath, VaultMount.create("approle"));
    then(template.opsForSys().getAuthMounts()).containsKey(authMountPath + "/");
    template.write("auth/" + authMountPath + "/role/testrole", CollectionsUtil.asMap(
            "secret_id_ttl", "10m",
            "token_num_uses", "10",
            "token_ttl", "20m",
            "token_max_ttl", "30m",
            "secret_id_num_uses", "40"
    ));
    Pair<String, String> credentials = getAppRoleCredentials(template, "auth/" + authMountPath + "/role/testrole");


    final Pair<String, String> wrapped = VaultConnector.doRequestWrappedToken(new VaultFeatureSettings(getVault().getUrl(), authMountPath, credentials.getFirst(), credentials.getSecond()));

    then(wrapped.getFirst()).isNotNull();
    then(wrapped.getSecond()).isNotNull();


    final CubbyholeAuthenticationOptions options = CubbyholeAuthenticationOptions.builder()
            .wrapped()
            .initialToken(VaultToken.of(wrapped.getFirst()))
            .build();
    final RestTemplate simpleTemplate = UtilKt.createRestTemplate(new VaultFeatureSettings(getVault().getUrl(), authMountPath, "", ""));
    final CubbyholeAuthentication authentication = new CubbyholeAuthentication(options, simpleTemplate);
    final TaskScheduler scheduler = new ConcurrentTaskScheduler();

    final MyLifecycleAwareSessionManager sessionManager = new MyLifecycleAwareSessionManager(authentication, simpleTemplate, scheduler);

    then(sessionManager.getSessionToken()).isNotNull();

    sessionManager.renewToken();

    then(sessionManager.getSessionToken()).isNotNull();
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Bean
public TaskScheduler taskScheduler () {
	ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
	scheduler.setThreadNamePrefix( CsapCoreService.class.getSimpleName() + "Scheduler" );
	scheduler.setPoolSize( 2 );
	return scheduler;
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
public void setScheduledTask(Runnable task, Trigger trigger ){
    
    if(this.scheduleFuture!=null){
        this.scheduleFuture.cancel(true);
    }
    
    TaskScheduler taskScheduler = this.taskRegistrar.getScheduler(); 
    this.scheduleFuture = taskScheduler.schedule(task, trigger);
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
	if (event.getApplicationContext() != this.applicationContext) {
		return;
	}

	if (this.scheduler != null) {
		this.registrar.setScheduler(this.scheduler);
	}

	Map<String, SchedulingConfigurer> configurers =
			this.applicationContext.getBeansOfType(SchedulingConfigurer.class);
	for (SchedulingConfigurer configurer : configurers.values()) {
		configurer.configureTasks(this.registrar);
	}

	if (this.registrar.hasTasks() && this.registrar.getScheduler() == null) {
		Map<String, ? super Object> schedulers = new HashMap<String, Object>();
		schedulers.putAll(this.applicationContext.getBeansOfType(TaskScheduler.class));
		schedulers.putAll(this.applicationContext.getBeansOfType(ScheduledExecutorService.class));
		if (schedulers.size() == 0) {
			// do nothing -> fall back to default scheduler
		}
		else if (schedulers.size() == 1) {
			this.registrar.setScheduler(schedulers.values().iterator().next());
		}
		else if (schedulers.size() >= 2){
			throw new IllegalStateException(
					"More than one TaskScheduler and/or ScheduledExecutorService  " +
					"exist within the context. Remove all but one of the beans; or " +
					"implement the SchedulingConfigurer interface and call " +
					"ScheduledTaskRegistrar#setScheduler explicitly within the " +
					"configureTasks() callback. Found the following beans: " + schedulers.keySet());
		}
	}

	this.registrar.afterPropertiesSet();
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
/**
 * 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());
	}
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Test
public void testReconnectDetailsSetServerAvailableAtStartup()
    throws MqttException, InterruptedException
{
    StaticApplicationContext applicationContext = getStaticApplicationContext();
    TaskScheduler taskScheduler = new ConcurrentTaskScheduler();
    MessageChannel inboundMessageChannel = new ExecutorSubscribableChannel();
    PahoAsyncMqttClientService service = new PahoAsyncMqttClientService(
        BrokerHelper.getProxyUri(), BrokerHelper.getClientId(), MqttClientConnectionType.PUBSUB,
        null);
    service.setApplicationEventPublisher(applicationContext);
    service.setInboundMessageChannel(inboundMessageChannel);
    service.subscribe(String.format("client/%s", BrokerHelper.getClientId()),
        MqttQualityOfService.QOS_0);
    service.getMqttConnectOptions().setCleanSession(true);
    service.setReconnectDetails(new DefaultReconnectService(), taskScheduler);
    Assert.assertTrue(service.start());
    Assert.assertTrue(service.isConnected());
    Assert.assertTrue(service.isStarted());
    // simulate a lost connection
    CRUSHER_PROXY.reopen();
    Assert.assertFalse(service.isStarted());
    Assert.assertFalse(service.isConnected());
    Thread.sleep(1100);
    Assert.assertTrue(service.isStarted());
    Assert.assertTrue(service.isConnected());
    Assert.assertEquals(2, clientConnectedCount.get());
    Assert.assertEquals(0, clientDisconnectedCount.get());
    Assert.assertEquals(1, clientLostConnectionCount.get());
    Assert.assertEquals(0, clientFailedConnectionCount.get());
    service.stop();
    service.close();
    applicationContext.close();
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Test
public void testReconnectDetailsSetServerUnavailableAtStartup()
    throws MqttException, InterruptedException
{
    StaticApplicationContext applicationContext = getStaticApplicationContext();
    CRUSHER_PROXY.close();
    TaskScheduler taskScheduler = new ConcurrentTaskScheduler();
    MessageChannel inboundMessageChannel = new ExecutorSubscribableChannel();
    PahoAsyncMqttClientService service = new PahoAsyncMqttClientService(
        BrokerHelper.getProxyUri(), BrokerHelper.getClientId(), MqttClientConnectionType.PUBSUB,
        null);
    service.setApplicationEventPublisher(applicationContext);
    service.setInboundMessageChannel(inboundMessageChannel);
    service.subscribe(String.format("client/%s", BrokerHelper.getClientId()),
        MqttQualityOfService.QOS_0);
    service.getMqttConnectOptions().setCleanSession(true);
    service.setReconnectDetails(new DefaultReconnectService(), taskScheduler);
    Assert.assertFalse(service.start());
    Assert.assertFalse(service.isConnected());
    Assert.assertFalse(service.isStarted());
    CRUSHER_PROXY.open();
    Thread.sleep(3100);
    Assert.assertTrue(service.isConnected());
    Assert.assertTrue(service.isStarted());
    Assert.assertEquals(1, clientConnectedCount.get());
    Assert.assertEquals(0, clientDisconnectedCount.get());
    Assert.assertEquals(0, clientLostConnectionCount.get());
    Assert.assertEquals(1, clientFailedConnectionCount.get());
    service.stop();
    service.close();
    applicationContext.close();
}
 

import org.springframework.scheduling.TaskScheduler; //导入依赖的package包/类
@Test
public void test()
{
    AbstractMqttClientService clientService = Mockito.mock(AbstractMqttClientService.class,
        Mockito.withSettings().useConstructor(MqttClientConnectionType.PUBSUB)
            .defaultAnswer(Mockito.CALLS_REAL_METHODS));
    Assert.assertEquals(MqttClientConnectionType.PUBSUB, clientService.getConnectionType());
    Assert.assertFalse(clientService.isStarted());
    Assert.assertNotNull(clientService.getMqttClientConfiguration());
    Assert.assertNull(clientService.applicationEventPublisher);
    clientService.setApplicationEventPublisher(Mockito.mock(ApplicationEventPublisher.class));
    Assert.assertNotNull(clientService.applicationEventPublisher);
    clientService.subscribe("inbound/client");
    Mockito.verify(clientService, Mockito.times(1)).subscribe(Mockito.anyString(),
        Mockito.any());
    Assert.assertNull(clientService.inboundMessageChannel);
    clientService.setInboundMessageChannel(Mockito.mock(MessageChannel.class));
    Assert.assertNotNull(clientService.inboundMessageChannel);
    Assert.assertNull(clientService.reconnectService);
    Assert.assertNull(clientService.taskScheduler);
    clientService.setReconnectDetails(Mockito.mock(ReconnectService.class),
        Mockito.mock(TaskScheduler.class));
    Assert.assertNotNull(clientService.reconnectService);
    Assert.assertNotNull(clientService.taskScheduler);
    Assert.assertEquals(0, clientService.getTopicSubscriptions().size());
    clientService.topicSubscriptions
        .add(new TopicSubscription("test", MqttQualityOfService.QOS_0));
    Assert.assertEquals(1, clientService.getTopicSubscriptions().size());
}