What should we pay attention to when developing multi-threads under springboot? (Summarize)

This article brings you what you need to pay attention to when developing multi-threads under springboot? (Summary), it has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

In the development process of multi-threaded programs based on springboot, the advantages of springboot can only be exerted because the spring container itself needs to be injected for management. Therefore, this article is mainly used to record some matters that need to be paid attention to when combining the two during development.

The first step is to inject the instance of the thread class into the sping container for management

@Configuration
@SpringBootApplication
@Import({ThreadConfig.class})
public class ThreadApp implements CommandLineRunner
{
    public static void main(String[] args) throws Exception {

        ApplicationContext app = SpringApplication.run(ThreadApp .class, args);
        //这里主要保存上下文对象实例，需要加上。SpringBootUtils类网上很多，可以自己搜下
        SpringBootUtils.setApplicationContext(app);

    }

    //access command line arguments
    @Override
    public void run(String... args) throws Exception {
        //do something
    }
}

//ComponentScan注解会扫描com.demo.thead下，也就是多线程类所在的包下的文件
@Configuration
@ComponentScan(basePackages = { "com.demo.thread"})
public class ThreadConfig{

}

Here we use the springboot @Import annotation to scan the ThreadConfig Examples with annotations in the package, such as @Component, etc. are injected into the spring container.

Then the thread is started. There are two situations in my business scenario:

1 , when the program is running, it starts automatically;

This is in a general executable program. Of course, it can be executed directly in the main function to start the thread through code. But in springboot, we can use the @PostConstruct annotation to allow the thread object that has been injected into the bean container to start automatically

@Component
public class  demoThread extends Thread
{
    //注意这里，如果你没有实现把多线程类的实例注入到spring容器中，这里你是无法拿到其他自动装配的对象实例的的，这也是我们第一步的意义所在。
    @Autowired
    private XxxService xxxService;

    @PostConstruct
    public void start() {
        super.start();
    }

    public void run() {
        // Ok,在这里你就可以实现线程要实现的功能逻辑了，自然也可以直接使用装配好的sevice对象实例。
        
    }
}

2. In the program, you need Started when a thread is opened, such as receiving data from kafka and starting thread processing. Of course, in this case, you also need to go through the first step and inject the thread class instance into the sping container

 private TaskThread thread;
    private ExecutorService taskPool= new ThreadPoolExecutor(
            5, 10, 1000,
            TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(10),
            new ThreadPoolExecutor.CallerRunsPolicy());  


    @KafkaListener(topics = "xxTopic")
    public void receive(ConsumerRecord<Object, Object> consumerRecord) {
           JSONObject json =  JSON.parseObject(consumerRecord.value().toString());
           //通过SpringBootUtils获取线程类的实例
           thread = SpringBootUtils.getBean(TaskThread.class);
           //启动线程
           //new Thread(thread).start() ; 
           //向线程对象里传值
           thread.init(i);
           //放入线程池执行
           taskPool.execute(thread);

    }

//注意这里是否添加@Scope("prototype")注解
@Component
@Scope("prototype")
public class TaskThread  implements Runnable{
    
    protected int value=0；

    @Autowired
    private XxxService xxxService;
    
    //ThreadLocal  对象，单例模式下可以保证成员变量的线程安全和独立性。
    public ThreadLocal<Integer> valueLocal =  new ThreadLocal < Integer > () {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    protected static final Logger LOG = LoggerFactory.getLogger(GpsTaskThread.class);
    
    @Override
    public final void run() {
        try { 
            LOG.info(value+"");
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void init(int Value) {
        this.value=Value;
    }


}

Here we need to pay attention to whether the TaskThread thread class needs to be added with the @Scope("prototype") annotation in spirngboot to set it to multiple instance mode or the default singleton mode.

In singleton mode, SpringBootUtils.getBean(TaskThread.class) returns the same object every time. Although there is no need to create a new object every time, the thread of the member variable cannot be guaranteed. Safety, that is to say, the values ​​of execution threads in the thread pool are shared. In the multi-instance mode, since a new thread object is created every time, the above problem does not exist.

So please pay attention here, whether it is my sample code above or ordinary web development, spirngboot defaults to singleton mode, and custom member variables are thread-unsafe. Synchronization needs to be done through ThreadLocal or other methods.

Back to our current business scenario, here we need each thread to process different values ​​without affecting each other, then set the TaskThread to multiple instances through the @Scope("prototype") annotation model.

Summary

Through the above example, we can see that the combination of springboot and multi-threading is relatively simple. Through configuration, we can manage thread classes in the spring container and also in threads. Use the object instance in the sping container. At the same time, we must consciously pay attention to thread safety issues and internal operating mechanism issues during use. Of course, the understanding here is still relatively simple. If there is anything incorrect, please point it out and explain it.

The above is the detailed content of What should we pay attention to when developing multi-threads under springboot? (Summarize). For more information, please follow other related articles on the PHP Chinese website!