Spring基于线程池的定时任务线挰异常实践

偏执的太偏执、 2022-04-06 02:18 95阅读 0赞

结论：Spring基于线程池的定时任务，线挰异常或内存溢出导致线程挂了，还会新启线程继续工作。

**实例重现：**

springMVC.properties

#the thread pool config 
    thread.corePoolSize=3
    thread.maxPoolSize=8
    thread.keepAliveSeconds=6
    thread.queueCapacity=2
    
    timing.query.status.interval=3000

springMVC-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    	xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:task="http://www.springframework.org/schema/task" 
    	xsi:schemaLocation="http://www.springframework.org/schema/beans 
                        http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.1.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
                        http://www.springframework.org/schema/task  
           				http://www.springframework.org/schema/task/spring-task-4.1.xsd
                        ">
                        
    	<context:component-scan base-package="com.bijian.study"></context:component-scan>   
        
    	
    	<context:property-placeholder location="classpath:springMVC.properties" />
        
        <mvc:annotation-driven></mvc:annotation-driven>
        
        <bean id="taskExecutor"
    		class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    		
    		<property name="corePoolSize" value="${thread.corePoolSize}" />
    		
    		<property name="maxPoolSize" value="${thread.maxPoolSize}" />
    		
    		<property name="queueCapacity" value="${thread.queueCapacity}" />
    		
    		<property name="keepAliveSeconds" value="${thread.keepAliveSeconds}" />
    		
    		<property name="rejectedExecutionHandler">
    			
    			
    			
    			
    			<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
    		</property>
    	</bean>
    	
    	<task:scheduled-tasks> 
    		
    		<task:scheduled ref="com.bijian.study.scheduled.TestScheduled" method="execute" fixed-delay="${timing.query.status.interval}" />
    	</task:scheduled-tasks>
    	
        <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">   
            <property name="viewClass"  
                value="org.springframework.web.servlet.view.JstlView" />   
            <property name="prefix" value="/WEB-INF/views" />
            <property name="suffix" value=".jsp" />   
        </bean>
    </beans>

ScheduledService.java

package com.bijian.study.service;
    
    public interface ScheduledService {
    
        void noNormalTest();
        
        void normalTest();
    }

ScheduledServiceImpl.java

package com.bijian.study.service.impl;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Service;
    
    import com.bijian.study.entity.Person;
    import com.bijian.study.service.ScheduledService;
    import com.bijian.study.util.JsonUtil;
    
    @Service("scheduledService")
    public class ScheduledServiceImpl implements ScheduledService {
    
        private static Logger logger = LoggerFactory.getLogger(HelloServiceImpl.class);
        
        private static int COUNT = 0;
        
        @Override
        public void noNormalTest() {
            
            logger.info("entry ScheduledService noNormalTest:{}" ,"entry");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            try {
                int j = 200/0;
                List<Person> personList = new ArrayList<Person>(3);
                personList.add(new Person("bijian", 10));
                personList.add(new Person("lisi", 20));
                personList.add(new Person("zhangshan", 30));
                
                List<Person> personList2 = new ArrayList<Person>();
                int i = 0;
                int count = personList.size();
                while(i < count) {
                    personList2.add(personList.get(i));
                    if(i == 2) {
                        personList2.clear();
                    }
                }
            }catch(Exception e) {
                logger.error("noNormalTest Exception:{}", e);
            }
            logger.info("entry ScheduledService noNormalTest:{}" ,"exit");
        }
    
        @Override
        public void normalTest() {
            
            logger.info("entry ScheduledService normalTest:{}" ,"entry");
    //        try {
    //            //Thread.sleep(10000);
    //        } catch (InterruptedException e) {
    //            // TODO Auto-generated catch block
    //            e.printStackTrace();
    //        }
            if(COUNT++ == 0) {
                List<Person> personList = new ArrayList<Person>();
                for(int i=0;i<1000000;i++) {
                    personList.add(new Person("bijian", 10));
                    personList.add(new Person("lisi", 20));
                    personList.add(new Person("zhangshan", 30));
                }
                logger.info("personList:{}", JsonUtil.toFullJson(personList));
            }
        }
    }

BaseScheduled.java

package com.bijian.study.scheduled;
    
    public interface BaseScheduled {
    
        void execute();
    }

TestScheduled.java

package com.bijian.study.scheduled;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    import org.springframework.stereotype.Service;
    
    import com.bijian.study.controller.HelloController;
    import com.bijian.study.service.ScheduledService;
    
    @Service(value = "com.bijian.study.scheduled.TestScheduled")
    public class TestScheduled implements BaseScheduled {
    
        private static Logger logger = LoggerFactory.getLogger(HelloController.class);
        
        @Autowired
        @Qualifier("taskExecutor")
        private ThreadPoolTaskExecutor threadPoolTaskExecutor;
        
        @Autowired
        private ScheduledService scheduledService;
        
        private static int COUNT = 0;
        
        @Override
        public void execute() {
            logger.info("enter TestScheduled");
            
            if(0 == COUNT) {
                threadPoolTaskExecutor.execute(new Runnable() {
                    
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(10000);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        scheduledService.noNormalTest();
                    }
                });
            }else {
                
    //            class MyThread implements Runnable {
    //                
    //                private String name;
    //                
    //                public MyThread(String name) {  
    //                    this.name = name;  
    //                }
    //                
    //                @Override
    //                public void run() {
                        try {
    //                        logger.info("MyThread name:{}", name);
    //                        try {
    //                            Thread.sleep(30000);
    //                        } catch (InterruptedException e) {
    //                            // TODO Auto-generated catch block
    //                            e.printStackTrace();
    //                        }
    //                        scheduledService.normalTest();
                        }catch(Throwable e) {
                            logger.info("exception:{}", e); 
                        }
    //                }
    //            }
    
                threadPoolTaskExecutor.execute(new Runnable() {
                    
                    @Override
                    public void run() {
                        scheduledService.normalTest();
                    }
                });
            }
            COUNT ++;
            
            logger.info("exit TestScheduled");
        }
    }

完整工程代码见附件《SpringMVC.zip》。