Design Considerations Using Springs `#Scheduled` and `#Async` Together - spring

Question

I have some questions about using Spring's #Scheduled and #Async functionality together.
Lets say my requirement is to process 5 rows from a DB every 1 second, so in 1 pass of the scheduler thread would create 5 asynchronous threads
to process each row from a Database.
My questions are as follows:
1) Is there an alternative way to creating 5 ascynchonis threads instead of using a while loop within the scheduled method?
One problem I see with this approach is the thread pools active count may not equal the max pool size and therefore the loop will not break before 1 second has passed.
2) In some cases the log statement in the AsyncService i.e. Executing dbItem on the following asyncExecutor : task-scheduler-1 displays task-scheduler-1 as the thread name and not async_thread_ as i would always expect?
3) If my scheduler thread takes longer than 1 second to run, what happens the subsequent pass of the scheduler?
The asyncExecutor:
#Override
#Bean(name="asyncExecutor")
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
threadPoolTaskExecutor.setCorePoolSize(5);
threadPoolTaskExecutor.setQueueCapacity(5);
threadPoolTaskExecutor.setMaxPoolSize(10);
threadPoolTaskExecutor.setThreadNamePrefix("async_thread_");
threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);
return threadPoolTaskExecutor;
}
which is injected into a class with a scheduled method:
#Autowired
#Qualifier("asyncExecutor")
private ThreadPoolTaskExecutor threadPoolTaskExecutor;
#Autowired
AsyncService asyncService;
#Autowired
private DaoService daoService;
#Scheduled(fixedRateString = "1000")
public void schedulerMetod() {
try {
while (threadPoolTaskExecutor.getActiveCount() < threadPoolTaskExecutor.getMaxPoolSize()) {
DbItem dbItem = daoService.retrieveNewItemFromDB();
if (dbItem != null){
asyncService.processNewItem(dbItem);
}
}
} catch (ObjectOptimisticLockingFailureException ole){
log.info(ole.getMessage());
} catch (Exception ex){
log.error(ex.getMessage());
}
}
#Service
public class AsyncServiceImpl implements AsyncService {
#Autowired
private TaskService taskService;
#Override
#Transactional
#Async("asyncExecutor")
public void processNewItem(DbItem dbItem) {
log.debug("Executing dbItem on the following asyncExecutor : " + Thread.currentThread().getName());
taskService.processNewItem(dbItem);
}
}

Answer 1

Using ThreadPoolTaskScheduler bean you will have twofold purpose as it implements both TaskExecutor (supports #Async) and TaskScheduler (supports #Scheduled) interfaces. You can configure like this:
#Bean
public ThreadPoolTaskScheduler taskScheduler() {
ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
threadPoolTaskScheduler.setPoolSize(5);
threadPoolTaskScheduler.setThreadNamePrefix("async_thread_");
threadPoolTaskScheduler.initialize();
return threadPoolTaskScheduler;
}
If you give another executor name such as taskScheduler1 then you should provide executor name as an attribute in #Async("taskScheduler1").
By this implementation you already have answers for your questions 1 & 2.
About your 3rd question, if all threads in your thread pool are busy then your schedulers do nothing until a thread released then it executes the scheduling task. You may think to give the thread pool a bigger size.
Last but not least, only usage of #Scheduled is enough as it works asynchronously.