Question

我正在编写一个Spring-Boot应用程序来监视目录并处理正在添加到其中的文件。我通过在我的Application类中创建ApplicationRunner来启动一个线程，该类调用使用@Async注释的方法：

@SpringBootApplication
@EnableAsync
public class Application {

    @Autowired
    private DirectoryMonitorService directoryMonitorService;

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    public ApplicationRunner startDirectoryMonitorService() {
        return args -> directoryMonitorService.monitorSourceDirectoty();
    }
}

以下是DirectoryMonitorService的代码，其中包含使用@Async注释的方法：

@Service
public class DirectoryMonitorService {

    private static final Logger logger = LogManager.getLogger(DirectoryMonitorService.class);

    @Value("${timeout}")
    private long timeout;

    @Autowired
    private WatchService watchService;

    @Async
    public void monitorSourceDirectoty() {
        while (true) {
            WatchKey watchKey;
            try {
                watchKey = watchService.poll(timeout, TimeUnit.SECONDS);
            } catch (ClosedWatchServiceException | InterruptedException e) {
                logger.error("Exception occured while polling from source file", e);
                return;
            }

            // process the WatchEvents

            if (!watchKey.reset()) {
                break;
            }
        }
    }
}

最后，我在这里创建ThreadPoolTaskExecutor：

public class AsyncConfig extends AsyncConfigurerSupport {

    private static final Logger logger = LogManager.getLogger(AsyncConfig.class);

    private static final String THREAD_NAME_PREFIX = "Parser-";

    @Value("${corePoolSize}")
    public int corePoolSize;

    @Value("${maxPoolSize}")
    public int maxPoolSize;

    @Value("${queueCapacity}")
    public int queueCapacity;

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setThreadNamePrefix(THREAD_NAME_PREFIX);
        executor.initialize();

        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (Throwable ex, Method method, Object... params) -> {
            logger.error("Exception message - " + ex.getMessage());
            logger.error("Method name - " + method.getName());
            for (Object param : params) {
                logger.error("Parameter value - " + param);
            }
        };
    }
}

不知怎的，我觉得这不是启动主线程最优雅的方式。有人有更好的解决方案吗？

此外，我宁愿将while (true)替换为Boolean变量，当Spring-Boot关闭时，我可以将其设置为false。有谁知道我需要为此实现哪个接口？

Answer 1

如果你想要一个非常简单的实现并且没有更可靠的话，这是正确的。

将@Async用于较短的任务，并且在重启等方面的能力非常有限。

而且，@Async将在每个监视序列激活时继续创建单独的线程，它将使线程池淹没并开始抛出异常，这非常明显，如果你有长时间运行的任务，

//处理WatchEvents

除了你的实施是正确的（在我看来）。

一些建议（如果你想让事情变得有趣/复杂）：

因此，您可以使用某种持久性机制显着跟踪文件，并触发解耦批处理（可以使用Spring Batch）来处理执行，并将这些批处理分成单独的UI或其他东西，您可以在UI上停止，启动和恢复这些批处理过程。

如何在Spring-Boot中启动（并最终停止）守护程序线程？

1 个答案: