Spring基于线程池的定时任务线挰异常实践-优快云博客

本文介绍了一个基于Spring的定时任务实现案例，详细分析了当线程池中的线程出现异常或内存溢出时，Spring如何确保定时任务的连续性和稳定性。通过配置线程池参数，演示了即使部分线程出现问题，也能启动新的线程继续执行任务。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

结论：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">
		<!-- 核心线程数，默认为1 -->
		<property name="corePoolSize" value="${thread.corePoolSize}" />
		<!-- 最大线程数，默认为Integer.MAX_VALUE -->
		<property name="maxPoolSize" value="${thread.maxPoolSize}" />
		<!-- 队列最大长度，一般需要设置值>=notifyScheduledMainExecutor.maxNum；默认为Integer.MAX_VALUE -->
		<property name="queueCapacity" value="${thread.queueCapacity}" />
		<!-- 线程池维护线程所允许的空闲时间，默认为60s -->
		<property name="keepAliveSeconds" value="${thread.keepAliveSeconds}" />
		<!-- 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者 -->
		<property name="rejectedExecutionHandler">
			<!-- AbortPolicy:直接抛出java.util.concurrent.RejectedExecutionException异常 -->
			<!-- CallerRunsPolicy:主线程直接执行该任务，执行完之后尝试添加下一个任务到线程池中，可以有效降低向线程池内添加任务的速度 -->
			<!-- DiscardOldestPolicy:抛弃旧的任务、暂不支持；会导致被丢弃的任务无法再次被执行 -->
			<!-- DiscardPolicy:抛弃当前任务、暂不支持；会导致被丢弃的任务无法再次被执行 -->
			<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
		</property>
	</bean>
	
	<task:scheduled-tasks> 
		<!--
		<task:scheduled ref="com.bijian.study.scheduled.TestScheduled" method="execute" cron="0 43 22 * * ?" />
		-->
		<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》。