Java ThreadPoolTaskExecutor.setAwaitTerminationSeconds方法代碼示例

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; //導入方法依賴的package包/類
@Bean
public ThreadPoolTaskExecutor bbApiThreadPoolExecutor() {
	ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
	pool.setCorePoolSize(corePoolSize);
	pool.setMaxPoolSize(maxPoolSize);
	pool.setAwaitTerminationSeconds(5);
	pool.setThreadNamePrefix("API-ThrP-");
	pool.setRejectedExecutionHandler(new ThreadPoolTaskRejectedHandler());
	return pool;
}
 

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; //導入方法依賴的package包/類
@Test
public void executor() throws InterruptedException {
    CountDownLatch lock = new CountDownLatch(1);
    ThreadPoolTaskExecutor pool = ThreadPoolTaskExecutorMetrics.monitor(registry, "exec", userTags);
    pool.setAwaitTerminationSeconds(1);
    pool.initialize();
    pool.execute(() -> {
        System.out.println("hello");
        lock.countDown();
    });
    lock.await();
    pool.shutdown();

    assertThat(registry.mustFind("exec").tags(userTags).timer().count()).isEqualTo(1L);
    registry.mustFind("exec.completed").tags(userTags).functionCounter();
    registry.mustFind("exec.queued").tags(userTags).gauge();
    registry.mustFind("exec.active").tags(userTags).gauge();
    registry.mustFind("exec.pool").tags(userTags).gauge();
}
 

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; //導入方法依賴的package包/類
@Test
public void monitorExecutorService() throws InterruptedException {
    CountDownLatch taskStart = new CountDownLatch(1);
    CountDownLatch taskComplete = new CountDownLatch(1);

    ThreadPoolTaskExecutor pool = ThreadPoolTaskExecutorMetrics.monitor(registry, "beep.pool", userTags);
    pool.setMaxPoolSize(1);
    pool.setAwaitTerminationSeconds(1);
    pool.setWaitForTasksToCompleteOnShutdown(true);
    pool.initialize();
    pool.submit(() -> {
        taskStart.countDown();
        taskComplete.await(1, TimeUnit.SECONDS);
        System.out.println("beep");
        return 0;
    });
    pool.submit(() -> System.out.println("boop"));

    taskStart.await(1, TimeUnit.SECONDS);
    assertThat(registry.mustFind("beep.pool.queued").tags(userTags).gauge().value()).isEqualTo(1.0);

    taskComplete.countDown();
    pool.shutdown();

    assertThat(registry.mustFind("beep.pool").tags(userTags).timer().count()).isEqualTo(2L);
    assertThat(registry.mustFind("beep.pool.queued").tags(userTags).gauge().value()).isEqualTo(0.0);
}
 

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; //導入方法依賴的package包/類
LongRunningMessageHandler(@NonNull ScheduledExecutorService timeoutExtensionExecutor,
        int maxNumberOfMessages, int numberOfThreads,
        @NonNull MessageHandlingRunnableFactory messageHandlingRunnableFactory,
        @NonNull VisibilityTimeoutExtenderFactory timeoutExtenderFactory,
        @NonNull MessageWorkerWithHeaders<I, O> worker, @NonNull Queue queue,
        @NonNull FinishedMessageCallback<I, O> finishedMessageCallback,
        @NonNull Duration timeUntilVisibilityTimeoutExtension,
        @NonNull Duration awaitShutDown) {
    if (timeUntilVisibilityTimeoutExtension.isZero() || timeUntilVisibilityTimeoutExtension
            .isNegative()) {
        throw new IllegalArgumentException("the timeout has to be > 0");
    }
    this.timeoutExtensionExecutor = timeoutExtensionExecutor;
    this.messageHandlingRunnableFactory = messageHandlingRunnableFactory;
    this.timeoutExtenderFactory = timeoutExtenderFactory;
    this.worker = worker;
    this.queue = queue;
    this.finishedMessageCallback = finishedMessageCallback;
    this.timeUntilVisibilityTimeoutExtension = timeUntilVisibilityTimeoutExtension;

    messageProcessingExecutor = new ThreadPoolTaskExecutor();
    messageProcessingExecutor.setMaxPoolSize(numberOfThreads);
    messageProcessingExecutor.setCorePoolSize(numberOfThreads);
    /*
     * Since we only accept new messages if one slot in the messagesInProcessing-Set
     * / executor is free we can schedule at least one message for instant execution
     * while (maxNumberOfMessages - 1) will be put into the queue
     */
    messageProcessingExecutor.setQueueCapacity(maxNumberOfMessages - 1);
    messageProcessingExecutor.setAwaitTerminationSeconds((int) awaitShutDown.getSeconds());
    if (awaitShutDown.getSeconds() > 0) {
        Runtime.getRuntime().addShutdownHook(new Thread(messageProcessingExecutor::shutdown));
    }
    messageProcessingExecutor.afterPropertiesSet();

    messagesInProcessing = new SetWithUpperBound<>(numberOfThreads);

    if (queue.getDefaultVisibilityTimeout().minusSeconds(5).compareTo(
            timeUntilVisibilityTimeoutExtension) < 0) {
        throw new IllegalStateException("The extension interval of "
                + timeUntilVisibilityTimeoutExtension.getSeconds()
                + " is too close to the VisibilityTimeout of " + queue
                        .getDefaultVisibilityTimeout().getSeconds()
                + " seconds of the queue, has to be at least 5 seconds less.");
    }
}