Question

我有一个多线程应用程序，我正在使用SpringBoot 1.5进行重新设计。请看以下示例：

@Service
@Lazy
class MyService {
    private static final Logger logger = LoggerFactory.getLogger(MyService.class);

    private String account;

    private boolean stopped = false;
    private boolean processing;

    public MyService(String account) {
        logger.debug("MyService constructor");
        this.account = account;
    }

    public void run() {
        logger.debug("starting thread " + account);        
        while(!stopped) {
            try {
                processing = false;
                Thread.sleep(5000); // awaiting some service response
                processing = true;
                Thread.sleep(3000); // processing service response
            } catch (InterruptedException e) {
                logger.error(null,e);
            }
        }
        logger.debug("finished gracefully");
    }

    public void stop() {
        stopped = true;
    }
}

@SpringBootApplication
public class App {

    private static final String[] accounts = { "user1", "user2", "user3" };

    public static void main(String[] args) {
        for(String account : accounts) {
            new Thread(() -> {
                ConfigurableApplicationContext context = SpringApplication.run(App.class, account);
                BeanFactory factory = context.getBeanFactory();
                MyService service = factory.getBean(MyService.class, account);

                context.addApplicationListener(event -> {
                    if(event instanceof ContextClosedEvent) {
                        service.stop();
                        // context.registerShutdownHook();
                        // context.close();
                    }
                });
                service.run();
            }).start();
        }
    }
}

application.properties

logging.level.com.example = DEBUG

的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>multicontext-app</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.3.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

</project>

我提出了多上下文配置，因为我想自动装配具有特定于线程的数据的“单例”范围bean。

问题：

这是为每个线程创建应用程序上下文的正确方法吗？
为什么我可以看到重复的日志消息（线程数平方时间）？例如，当运行3个线程时，“MyService构造函数”消息被打印9次，而不是3次（每个上下文一个实例）。
如何正常关闭每个服务线程，考虑到如果服务正在等待响应而不处理它，则无需等待？目前，当应用程序停止时，我看不到“已完成优雅”消息。
我是否需要致电context.close()或context.registerShutdownHook()或两者？什么时候我应该这样做，发生什么事我不会这样做？

Answer 1

有不同的方法可以实现正常关闭，我将通过使用Scheduled技巧（我从StackOverflow的某处学习）来显示一个。

计划技巧在应用程序上下文启动时启动任务，但从未再次安排任务（initialDelay = 0L, fixedDelay = Long.MAX_VALUE），从而有效地将计划任务转换为后台服务。 Spring会安排任务，您可以通过SchedulingConfigurer配置Spring如何处理计划任务，从而控制计划任务，包括关机。

停止运行任务的正常方式是中断它们，所以我用它来停止服务。但是，如果确实需要，您仍然可以使用ContextClosedEvent来停止运行服务。

由于计划任务是以异步方式启动的，因此不再需要在main方法的单独线程中启动应用程序上下文。

我在命令行上使用以下方法测试：
mvn clean spring-boot:run
和
mvn clean package spring-boot:repackage
java -jar target\[app].jar
按“ctrl-c”开始关机。

@SpringBootApplication
@EnableScheduling
public class App implements SchedulingConfigurer {

    private static final Logger log = LoggerFactory.getLogger(App.class);
    private static final AtomicInteger ctxCount = new AtomicInteger();

    private static final String[] accounts = { "user1", "user2", "user3" };

    public static void main(String[] args) {

        Arrays.stream(accounts).forEach(account -> {
            ConfigurableApplicationContext context = SpringApplication.run(App.class, account);
            context.getBeanFactory().getBean(MyService.class, account);
        });
    }

    @Bean(destroyMethod="shutdown")
    public Executor taskScheduler() {
        // https://github.com/spring-projects/spring-boot/issues/7779
        final String prefix = "app-" + ctxCount.incrementAndGet() + "-mcsch-";
        log.debug("Creating task scheduler {}", prefix);
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(1);
        scheduler.setThreadNamePrefix(prefix);
        scheduler.setWaitForTasksToCompleteOnShutdown(true);
        scheduler.setAwaitTerminationSeconds(20);
        return scheduler;
    }

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        log.debug("Setting task scheduler.");
        taskRegistrar.setScheduler(taskScheduler());
    }

    @Service
    @Lazy
    static class MyService {

        private String account;

        public MyService(String account) {
            log.debug("{} - MyService constructor", account);
            this.account = account;
        }

        // trick to "run at startup"
        @Scheduled(initialDelay = 0L, fixedDelay = Long.MAX_VALUE)
        public void run() {
            boolean stopped = false;
            while(!stopped) {
                try {
                    log.debug("{} - sleeping", account);        
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    log.debug("{} - sleep interrupted", account);
                    stopped = true;
                }
            }
            log.debug("{} - finished gracefully", account);
        }
    } // MyService

}

运行多个线程（每个线程都有自己的应用程序上下文）并正常关闭

1 个答案: