【小家Spring】Spring任务调度@Scheduled的使用以及原理、源码分析(@EnableScheduling)

前言

JDK给我们提供了定时任务的能力,详解之前有篇博文: 【小家java】Java定时任务ScheduledThreadPoolExecutor详解以及与Timer、TimerTask的区别(执行指定次数停止任务)

而Spring基于此做了更便捷的封装,使得我们使用起来异常的方便~

定时任务也是平时开发不可缺少的一个使用场景,本文主要看看Spring是怎么来实现这一套逻辑的?

Demo

@Service
public class HelloServiceImpl implements HelloService {
    // @Schedules
    // 它是允许重复注解的~~~~
    //@Scheduled(cron = "0/5 * * * * ?")
    @Scheduled(cron = "0/2 * * * * ?") // 每2秒钟执行一次
    public void job1() {
        System.out.println("我执行了~~" + LocalTime.now());
    }
}

然后让Spring开启定时任务的支持即可。

@Configuration
@EnableScheduling // 开启定时任务
public class RootConfig {

}

输出如下:每两秒钟执行一次

我执行了~~14:46:36.003
我执行了~~14:46:38.002
我执行了~~14:46:40.001
我执行了~~14:46:42.001
我执行了~~14:46:44.002
...

原理、源码分析

很显然又是@EnableXXX的设计模式,因此入口又从该注解开始吧~~~

@EnableScheduling

//@since 3.1
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(SchedulingConfiguration.class)
@Documented
public @interface EnableScheduling {

}

可以看出它没有任何属性。所以只有一个@Import在起作用,因此重点看看SchedulingConfiguration

它的效果同XML中的<task:annotation-driven>

SchedulingConfiguration

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class SchedulingConfiguration {

	@Bean(name = TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() {
		return new ScheduledAnnotationBeanPostProcessor();
	}

}

同样的,也非常非常的简单。只是向容器注入了一个ScheduledAnnotationBeanPostProcessor,它是一个PostProcessor,同时也是一个SmartInitializingSingleton等等

ScheduledAnnotationBeanPostProcessor

Scheduled注解后处理器,项目启动时会扫描所有标记了@Scheduled注解的方法,封装成ScheduledTask注册起来。

这个处理器是处理定时任务的核心类,比较复杂。下面也是结合源码,来看看它具体的一个工作内容:

// 首先:非常震撼的是,它实现的接口非常的多。还好的是,大部分接口我们都很熟悉了。
// MergedBeanDefinitionPostProcessor:它是个BeanPostProcessor
// DestructionAwareBeanPostProcessor:在销毁此Bean的时候,会调用对应方法
// SmartInitializingSingleton:它会在所有的单例Bean都完成了初始化后,调用这个接口的方法
// EmbeddedValueResolverAware, BeanNameAware, BeanFactoryAware, ApplicationContextAware:都是些感知接口
// DisposableBean:该Bean销毁的时候会调用
// ApplicationListener<ContextRefreshedEvent>:监听容器的`ContextRefreshedEvent`事件
// ScheduledTaskHolder:维护本地的ScheduledTask实例
public class ScheduledAnnotationBeanPostProcessor
		implements ScheduledTaskHolder, MergedBeanDefinitionPostProcessor, DestructionAwareBeanPostProcessor,
		Ordered, EmbeddedValueResolverAware, BeanNameAware, BeanFactoryAware, ApplicationContextAware,
		SmartInitializingSingleton, ApplicationListener<ContextRefreshedEvent>, DisposableBean {

	/**
	 * The default name of the {@link TaskScheduler} bean to pick up: "taskScheduler".
	 * <p>Note that the initial lookup happens by type; this is just the fallback
	 * in case of multiple scheduler beans found in the context.
	 * @since 4.2
	 */
	 // 看着注释就知道,和@Async的默认处理一样~~~~先类型  在回退到名称
	public static final String DEFAULT_TASK_SCHEDULER_BEAN_NAME = "taskScheduler";
	// 调度器(若我们没有配置,它是null的)
	@Nullable
	private Object scheduler;
	
	// 这些都是Awire感知接口注入进来的~~
	@Nullable
	private StringValueResolver embeddedValueResolver;
	@Nullable
	private String beanName;
	@Nullable
	private BeanFactory beanFactory;
	@Nullable
	private ApplicationContext applicationContext;

	// ScheduledTaskRegistrar:ScheduledTask注册中心,ScheduledTaskHolder接口的一个重要的实现类,维护了程序中所有配置的ScheduledTask
	// 内部会处理调取器得工作,因此我建议先移步,看看这个类得具体分析
	private final ScheduledTaskRegistrar registrar = new ScheduledTaskRegistrar();

	// 缓存,没有被标注注解的class们  
	// 这有个技巧,使用了newSetFromMap,自然而然的这个set也就成了一个线程安全的set
	private final Set<Class<?>> nonAnnotatedClasses = Collections.newSetFromMap(new ConcurrentHashMap<>(64));

	// 缓存对应的Bean上  里面对应的 ScheduledTask任务。可议有多个哦~~
	// 注意:此处使用了IdentityHashMap
	private final Map<Object, Set<ScheduledTask>> scheduledTasks = new IdentityHashMap<>(16);

	// 希望此processor是最后执行的~
	@Override
	public int getOrder() {
		return LOWEST_PRECEDENCE;
	}

	 //Set the {@link org.springframework.scheduling.TaskScheduler} that will invoke the scheduled methods
	 // 也可以是JDK的ScheduledExecutorService(内部会给你包装成一个TaskScheduler)
	 // 若没有指定。那就会走默认策略:去从起中先按照类型找`TaskScheduler`该类型(或者ScheduledExecutorService这个类型也成)的。
	 // 若有多个该类型或者找不到,就安好"taskScheduler"名称去找 
	 // 再找不到,就用系统默认的:
	public void setScheduler(Object scheduler) {
		this.scheduler = scheduler;
	}
	...
	
	// 此方法会在该容器内所有的单例Bean已经初始化全部结束后,执行
	@Override
	public void afterSingletonsInstantiated() {
		// Remove resolved singleton classes from cache
		// 因为已经是最后一步了,所以这个缓存可议清空了
		this.nonAnnotatedClasses.clear();
		
		// 在容器内运行,ApplicationContext都不会为null
		if (this.applicationContext == null) {
			// Not running in an ApplicationContext -> register tasks early...
			// 如果不是在ApplicationContext下运行的,那么就应该提前注册这些任务
			finishRegistration();
		}
	}

	// 兼容容器刷新的时间(此时候容器硬启动完成了)   它还在`afterSingletonsInstantiated`的后面执行
	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {
		// 这个动作务必要做:因为Spring可能有多个容器,所以可能会发出多个ContextRefreshedEvent 事件
		// 显然我们只处理自己容器发出来得事件,别的容器发出来我不管~~
		if (event.getApplicationContext() == this.applicationContext) {
			// Running in an ApplicationContext -> register tasks this late...
			// giving other ContextRefreshedEvent listeners a chance to perform
			// their work at the same time (e.g. Spring Batch's job registration).
			// 为其他ContextRefreshedEvent侦听器提供同时执行其工作的机会(例如,Spring批量工作注册)
			finishRegistration();
		}
	}

	private void finishRegistration() {
		// 如果setScheduler了,就以调用者指定的为准~~~
		if (this.scheduler != null) {
			this.registrar.setScheduler(this.scheduler);
		}

		// 这里继续厉害了:从容器中找到所有的接口`SchedulingConfigurer`的实现类(我们可议通过实现它定制化scheduler)
		if (this.beanFactory instanceof ListableBeanFactory) {
			Map<String, SchedulingConfigurer> beans =
					((ListableBeanFactory) this.beanFactory).getBeansOfType(SchedulingConfigurer.class);
			List<SchedulingConfigurer> configurers = new ArrayList<>(beans.values());
			
			// 同@Async只允许设置一个不一样的是,这里每个都会让它生效
			// 但是平时使用,我们自顶一个类足矣~~~
			AnnotationAwareOrderComparator.sort(configurers);
			for (SchedulingConfigurer configurer : configurers) {
				configurer.configureTasks(this.registrar);
			}
		}
		
		// 至于task是怎么注册进registor的,请带回看`postProcessAfterInitialization`这个方法的实现
		// 有任务并且registrar.getScheduler() == null,那就去容器里找来试试~~~
		if (this.registrar.hasTasks() && this.registrar.getScheduler() == null) {
			...
			// 这块逻辑和@Async的处理一毛一样。忽略了 主要看看resolveSchedulerBean()这个方法即可
		}

		this.registrar.afterPropertiesSet();
	}
	// 从容器中去找一个
	private <T> T resolveSchedulerBean(BeanFactory beanFactory, Class<T> schedulerType, boolean byName) {
		// 若按名字去查找,那就按照名字找
		if (byName) {
			T scheduler = beanFactory.getBean(DEFAULT_TASK_SCHEDULER_BEAN_NAME, schedulerType);

			// 这个处理非常非常有意思,就是说倘若找到了你可以在任意地方直接@Autowired这个Bean了,可以拿这个共用Scheduler来调度我们自己的任务啦~~
			if (this.beanName != null && this.beanFactory instanceof ConfigurableBeanFactory) {
				((ConfigurableBeanFactory) this.beanFactory).registerDependentBean(
						DEFAULT_TASK_SCHEDULER_BEAN_NAME, this.beanName);
			}
			return scheduler;
		}
		// 按照schedulerType该类型的名字匹配resolveNamedBean  底层依赖:getBeanNamesForType
		else if (beanFactory instanceof AutowireCapableBeanFactory) {
			NamedBeanHolder<T> holder = ((AutowireCapableBeanFactory) beanFactory).resolveNamedBean(schedulerType);
			if (this.beanName != null && beanFactory instanceof ConfigurableBeanFactory) {
				((ConfigurableBeanFactory) beanFactory).registerDependentBean(holder.getBeanName(), this.beanName);
			}
			return holder.getBeanInstance();
		}
		// 按照类型找
		else {
			return beanFactory.getBean(schedulerType);
		}
	}


	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
	}
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) {
		return bean;
	}

	// Bean初始化完成后执行。去看看Bean里面有没有标注了@Scheduled的方法~~
	@Override
	public Object postProcessAfterInitialization(final Object bean, String beanName) {
		// 拿到目标类型(因为此类有可能已经被代理过)
		Class<?> targetClass = AopProxyUtils.ultimateTargetClass(bean);
		// 这里对没有标注注解的类做了一个缓存,防止从父去扫描(毕竟可能有多个容器,可能有重复扫描的现象)
		if (!this.nonAnnotatedClasses.contains(targetClass)) {

			// 如下:主要用到了MethodIntrospector.selectMethods  这个内省方法工具类的这个g工具方法,去找指定Class里面,符合条件的方法们
			Map<Method, Set<Scheduled>> annotatedMethods = MethodIntrospector.selectMethods(targetClass,
					(MethodIntrospector.MetadataLookup<Set<Scheduled>>) method -> {
					
						//过滤Method的核心逻辑就是是否标注有此注解(Merged表示标注在父类、或者接口处也是ok的)
						Set<Scheduled> scheduledMethods = AnnotatedElementUtils.getMergedRepeatableAnnotations(
								method, Scheduled.class, Schedules.class);
						return (!scheduledMethods.isEmpty() ? scheduledMethods : null);
					});
			if (annotatedMethods.isEmpty()) {
				this.nonAnnotatedClasses.add(targetClass);
				if (logger.isTraceEnabled()) {
					logger.trace("No @Scheduled annotations found on bean class: " + bean.getClass());
				}
			}
			// 此处相当于已经找到了对应的注解方法~~~
			else {
				// Non-empty set of methods
				// 这里有一个双重遍历。因为一个方法上,可能重复标注多个这样的注解~~~~~
				// 所以最终遍历出来后,就交给processScheduled(scheduled, method, bean)去处理了
				annotatedMethods.forEach((method, scheduledMethods) ->
						scheduledMethods.forEach(scheduled -> processScheduled(scheduled, method, bean)));
				if (logger.isDebugEnabled()) {
					logger.debug(annotatedMethods.size() + " @Scheduled methods processed on bean '" + beanName + "': " + annotatedMethods);
				}
			}
		}
		return bean;
	}

	// 这个方法就是灵魂了。就是执行这个注解,最终会把这个任务注册进去,并且启动的~~~
	protected void processScheduled(Scheduled scheduled, Method method, Object bean) {
		try {
			// 标注此注解的方法必须是无参的方法
			Assert.isTrue(method.getParameterCount() == 0, "Only no-arg methods may be annotated with @Scheduled");

			// 拿到最终要被调用的方法  做这么一步操作主要是防止方法被代理了
			Method invocableMethod = AopUtils.selectInvocableMethod(method, bean.getClass());
			// 把该方法包装成一个Runnable 线程~~~
			Runnable runnable = new ScheduledMethodRunnable(bean, invocableMethod);
			boolean processedSchedule = false;
			String errorMessage = "Exactly one of the 'cron', 'fixedDelay(String)', or 'fixedRate(String)' attributes is required";

			// 装载任务,这里长度定为4,因为Spring认为标注4个注解还不够你用的?
			Set<ScheduledTask> tasks = new LinkedHashSet<>(4);

			// Determine initial delay
			// 计算出延时多长时间执行 initialDelayString 支持占位符如:@Scheduled(fixedDelayString = "${time.fixedDelay}")
			// 这段话得意思是,最终拿到一个initialDelay值~~~~~Long型的
			long initialDelay = scheduled.initialDelay();
			String initialDelayString = scheduled.initialDelayString();
			if (StringUtils.hasText(initialDelayString)) {
				Assert.isTrue(initialDelay < 0, "Specify 'initialDelay' or 'initialDelayString', not both");
				if (this.embeddedValueResolver != null) {
					initialDelayString = this.embeddedValueResolver.resolveStringValue(initialDelayString);
				}
				if (StringUtils.hasLength(initialDelayString)) {
					try {
						initialDelay = parseDelayAsLong(initialDelayString);
					}
					catch (RuntimeException ex) {
						throw new IllegalArgumentException(
								"Invalid initialDelayString value \"" + initialDelayString + "\" - cannot parse into long");
					}
				}
			}

			// Check cron expression
			// 解析cron
			String cron = scheduled.cron();
			if (StringUtils.hasText(cron)) {
				String zone = scheduled.zone();
				// 由此课件,cron也可以使用占位符。把它配置在配置文件里就成~~~zone也是支持占位符的
				if (this.embeddedValueResolver != null) {
					cron = this.embeddedValueResolver.resolveStringValue(cron);
					zone = this.embeddedValueResolver.resolveStringValue(zone);
				}
				if (StringUtils.hasLength(cron)) {
					Assert.isTrue(initialDelay == -1, "'initialDelay' not supported for cron triggers");
					processedSchedule = true;
					TimeZone timeZone;
					if (StringUtils.hasText(zone)) {
						timeZone = StringUtils.parseTimeZoneString(zone);
					}
					else {
						timeZone = TimeZone.getDefault();
					}

					// 这个相当于,如果配置了cron,它就是一个task了,就可以吧任务注册进registrar里面了
					// 这里面的处理是。如果已经有调度器taskScheduler了,那就立马准备执行了															
					tasks.add(this.registrar.scheduleCronTask(new CronTask(runnable, new CronTrigger(cron, timeZone))));
				}
			}

			// At this point we don't need to differentiate between initial delay set or not anymore
			if (initialDelay < 0) {
				initialDelay = 0;
			}
			...
			// 下面就不再说了,就是解析fixed delay、fixed rated、
			
			// Check whether we had any attribute set
			Assert.isTrue(processedSchedule, errorMessage);

			// Finally register the scheduled tasks
			// 最后吧这些任务都放在全局属性里保存起来~~~~
			// getScheduledTasks()方法是会把所有的任务都返回出去的~~~ScheduledTaskHolder接口就一个Set<ScheduledTask> getScheduledTasks();方法嘛
			synchronized (this.scheduledTasks) {
				Set<ScheduledTask> registeredTasks = this.scheduledTasks.get(bean);
				if (registeredTasks == null) {
					registeredTasks = new LinkedHashSet<>(4);
					this.scheduledTasks.put(bean, registeredTasks);
				}
				registeredTasks.addAll(tasks);
			}
		}
		catch (IllegalArgumentException ex) {
			throw new IllegalStateException(
					"Encountered invalid @Scheduled method '" + method.getName() + "': " + ex.getMessage());
		}
	}

	private static long parseDelayAsLong(String value) throws RuntimeException {
		if (value.length() > 1 && (isP(value.charAt(0)) || isP(value.charAt(1)))) {
			return Duration.parse(value).toMillis();
		}
		return Long.parseLong(value);
	}

	private static boolean isP(char ch) {
		return (ch == 'P' || ch == 'p');
	}

	 //@since 5.0.2 获取到所有的任务。包含本实例的,以及registrar(手动注册)的所有任务
	@Override
	public Set<ScheduledTask> getScheduledTasks() {
		Set<ScheduledTask> result = new LinkedHashSet<>();
		synchronized (this.scheduledTasks) {
			Collection<Set<ScheduledTask>> allTasks = this.scheduledTasks.values();
			for (Set<ScheduledTask> tasks : allTasks) {
				result.addAll(tasks);
			}
		}
		result.addAll(this.registrar.getScheduledTasks());
		return result;
	}

	// Bean销毁之前执行。移除掉所有的任务,并且取消所有的任务
	@Override
	public void postProcessBeforeDestruction(Object bean, String beanName) {
		Set<ScheduledTask> tasks;
		synchronized (this.scheduledTasks) {
			tasks = this.scheduledTasks.remove(bean);
		}
		if (tasks != null) {
			for (ScheduledTask task : tasks) {
				task.cancel();
			}
		}
	}
	...
}

这里可以说已经把Spring怎么发现Task、执行Task的流程讲解通了。这里忽略了一个重要的类:ScheduledTaskRegistrar,它整体作为一个注册中心的角色,非常的重要,下面讲解它:

ScheduledTaskRegistrar

ScheduledTask注册中心,ScheduledTaskHolder接口的一个重要的实现类,维护了程序中所有配置的ScheduledTask

它是ScheduledAnnotationBeanPostProcessor的一个重要角色。

//@since 3.0 它在Spring3.0就有了
// 这里面又有一个重要的接口:我们可议通过扩展实现此接口,来定制化属于自己的ScheduledTaskRegistrar 下文会有详细介绍
// 它实现了InitializingBean和DisposableBean,所以我们也可以把它放进容器里面
public class ScheduledTaskRegistrar implements ScheduledTaskHolder, InitializingBean, DisposableBean {
	
	// 任务调度器
	@Nullable
	private TaskScheduler taskScheduler;
	// 该类事JUC包中的类
	@Nullable
	private ScheduledExecutorService localExecutor;

	// 对任务进行分类 管理
	@Nullable
	private List<TriggerTask> triggerTasks;
	@Nullable
	private List<CronTask> cronTasks;
	@Nullable
	private List<IntervalTask> fixedRateTasks;
	@Nullable
	private List<IntervalTask> fixedDelayTasks;
	private final Map<Task, ScheduledTask> unresolvedTasks = new HashMap<>(16);
	private final Set<ScheduledTask> scheduledTasks = new LinkedHashSet<>(16);

	// 调用者可议自己指定一个TaskScheduler 
	public void setTaskScheduler(TaskScheduler taskScheduler) {
		Assert.notNull(taskScheduler, "TaskScheduler must not be null");
		this.taskScheduler = taskScheduler;
	}

	// 这里,如果你指定的是个TaskScheduler、ScheduledExecutorService都是阔仪得
	// ConcurrentTaskScheduler也是一个TaskScheduler的实现类
	public void setScheduler(@Nullable Object scheduler) {
		if (scheduler == null) {
			this.taskScheduler = null;
		}
		else if (scheduler instanceof TaskScheduler) {
			this.taskScheduler = (TaskScheduler) scheduler;
		}
		else if (scheduler instanceof ScheduledExecutorService) {
			this.taskScheduler = new ConcurrentTaskScheduler(((ScheduledExecutorService) scheduler));
		}
		else {
			throw new IllegalArgumentException("Unsupported scheduler type: " + scheduler.getClass());
		}
	}

	@Nullable
	public TaskScheduler getScheduler() {
		return this.taskScheduler;
	}
	// 将触发的任务指定为可运行文件(任务)和触发器对象的映射  typically custom implementations of the {@link Trigger} interface
	// org.springframework.scheduling.Trigger
	public void setTriggerTasks(Map<Runnable, Trigger> triggerTasks) {
		this.triggerTasks = new ArrayList<>();
		triggerTasks.forEach((task, trigger) -> addTriggerTask(new TriggerTask(task, trigger)));
	}

	// 主要处理` <task:*>`这种配置
	public void setTriggerTasksList(List<TriggerTask> triggerTasks) {
		this.triggerTasks = triggerTasks;
	}
	public List<TriggerTask> getTriggerTaskList() {
		return (this.triggerTasks != null? Collections.unmodifiableList(this.triggerTasks) :
				Collections.emptyList());
	}

	// 这个一般是最常用的 CronTrigger:Trigger的一个实现类。另一个实现类为PeriodicTrigger
	public void setCronTasks(Map<Runnable, String> cronTasks) {
		this.cronTasks = new ArrayList<>();
		cronTasks.forEach(this::addCronTask);
	}
	public void setCronTasksList(List<CronTask> cronTasks) {
		this.cronTasks = cronTasks;
	}
	public List<CronTask> getCronTaskList() {
		return (this.cronTasks != null ? Collections.unmodifiableList(this.cronTasks) :
				Collections.emptyList());
	}
	...
	// 判断是否还有任务
	public boolean hasTasks() {
		return (!CollectionUtils.isEmpty(this.triggerTasks) ||
				!CollectionUtils.isEmpty(this.cronTasks) ||
				!CollectionUtils.isEmpty(this.fixedRateTasks) ||
				!CollectionUtils.isEmpty(this.fixedDelayTasks));
	}


	/**
	 * Calls {@link #scheduleTasks()} at bean construction time.
	 */
	// 这个方法很重要:开始执行所有已经注册的任务们~~
	@Override
	public void afterPropertiesSet() {
		scheduleTasks();
	}
	@SuppressWarnings("deprecation")
	protected void scheduleTasks() {
		// 这一步非常重要:如果我们没有指定taskScheduler ,这里面会new一个newSingleThreadScheduledExecutor
		// 显然它并不是是一个真的线程池,所以他所有的任务还是得一个一个的One by One的执行的  请务必注意啊~~~~
		// 默认是它:Executors.newSingleThreadScheduledExecutor() 所以肯定串行啊
		if (this.taskScheduler == null) {
			this.localExecutor = Executors.newSingleThreadScheduledExecutor();
			this.taskScheduler = new ConcurrentTaskScheduler(this.localExecutor);
		}


		// 加下来做得事,就是借助TaskScheduler来启动每个任务
		// 并且把启动了的任务最终保存到scheduledTasks里面~~~ 后面还会介绍TaskScheduler的两个实现
		if (this.triggerTasks != null) {
			for (TriggerTask task : this.triggerTasks) {
				addScheduledTask(scheduleTriggerTask(task));
			}
		}
		if (this.cronTasks != null) {
			for (CronTask task : this.cronTasks) {
				addScheduledTask(scheduleCronTask(task));
			}
		}
		if (this.fixedRateTasks != null) {
			for (IntervalTask task : this.fixedRateTasks) {
				addScheduledTask(scheduleFixedRateTask(task));
			}
		}
		if (this.fixedDelayTasks != null) {
			for (IntervalTask task : this.fixedDelayTasks) {
				addScheduledTask(scheduleFixedDelayTask(task));
			}
		}
	}

	private void addScheduledTask(@Nullable ScheduledTask task) {
		if (task != null) {
			this.scheduledTasks.add(task);
		}
	}
	@Override
	public Set<ScheduledTask> getScheduledTasks() {
		return Collections.unmodifiableSet(this.scheduledTasks);
	}

	// 销毁: task.cancel()取消所有的任务  调用的是Future.cancel()
	// 并且关闭线程池localExecutor.shutdownNow()
	@Override
	public void destroy() {
		for (ScheduledTask task : this.scheduledTasks) {
			task.cancel();
		}
		if (this.localExecutor != null) {
			this.localExecutor.shutdownNow();
		}
	}

}

展示默认情况下任务不能并行的Demo

首先,采用全默认配置执行定时器:

    @Scheduled(cron = "0/2 * * * * ?")
    public void fun1(){
        System.out.println(Thread.currentThread().getName());
        // 模拟任务内抛出异常~~~~
        throw new RuntimeException("aaaaaaaa");
    }
    
pool-2-thread-1_61
pool-2-thread-1_61
pool-2-thread-1_61
pool-2-thread-1_61
...

从这里可以得出结论:默认情况下使用的使用的是线程池但是因为只有一个线程,所以使用的都是它。但是需要注意的是,虽然是同一个线程但是即使内部抛出了异常,线程也不会终止的,所以请放心。原因如下: DelegatingErrorHandlingRunnable#run

public class DelegatingErrorHandlingRunnable implements Runnable {
	...
	@Override
	public void run() {
		try {
			this.delegate.run();
		}
		catch (UndeclaredThrowableException ex) {
			this.errorHandler.handleError(ex.getUndeclaredThrowable());
		}
		catch (Throwable ex) {
			this.errorHandler.handleError(ex);
		}
	}
	...	
}

人家都给你try住了,并且还交给了你自定义的errorHandler去处理,可谓还是非常友好的~

让任务并行执行?

不解释了,就是自定义配置一个线程池给它,提高执行效率。具体请参照下面有标准使用方式~~~

备注:SpringBoot本身默认的执行方式是串行执行,无论有多少task,都是一个线程串行执行。若你所想提高效率,请提供线程池

@Scheduled注解各属性含义

参考:@Scheduled注解各参数详解

Quartz和Spring schedule简单对比

Quartz是个著名的、强大的、开源的任务调度框架。下面来几点非常简单的对比,供各位参考:

备注:这里只谈单机版的,不说分布式的,在分布式中有其他的框架可以解决,同时quartz也是可以支持分布式的。

  • schedule:支持cron、不支持持久化、开发非常非常非常简单
  • quartz:支持cron、支持持久化、开发复杂

虽然quartz看起来更强大些、也支持分布式。但是,但是,但是和@Schedule简单的开发步骤,如果你只是简单的任务,完全用Spring的就可以了。 若是分布式环境,我们一般也不会直接使用quartz,而是选择其它更适合的产品(虽然它有可能是基于quartz定制的~~~) 我们可以把@Schedule看做一个轻量级的Quartz,但它使用起来极其方便

使用推荐配置

默认的,SchedulingConfigurer 使用的也是单线程的方式,如果需要配置多线程,则需要指定 PoolSize

@EnableScheduling
@Configuration
public class ScheduldConfig implements SchedulingConfigurer {

	// 下面是推荐的配置,当然你也可以简单粗暴的使用它:  开启100个核心线程  足够用了吧
	// taskRegistrar.setScheduler(Executors.newScheduledThreadPool(100));
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        // 方式一:可议直接使用一个TaskScheduler  然后设置上poolSize等参数即可  (推荐)
        //ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        //taskScheduler.setPoolSize(10);
        //taskScheduler.initialize(); // 记得调用啊
        //taskRegistrar.setTaskScheduler(taskScheduler);

        // 方式二:ScheduledExecutorService(使用ScheduledThreadPoolExecutor,它继承自JUC的ThreadPoolExecutor,是一个和任务调度相关的线程池)
        ScheduledThreadPoolExecutor poolExecutor = new ScheduledThreadPoolExecutor(10);
        taskRegistrar.setScheduler(poolExecutor);

        // =========示例:这里,我们也可以注册一个任务,一直执行的~~~=========
        taskRegistrar.addFixedRateTask(() -> System.out.println("执行定时任务1: " + new Date()), 1000);

    }
}

其实这里给了我们打开了一个思路。通过这我们可以捕获到ScheduledTaskRegistrar,从而我们可以通过接口动态的去改变任务的执行时间、以及对任务的增加、删、改、查等操作,有兴趣的小伙伴可以动手试试

总结

Task在平时业务开发中确实使用非常的广泛,但在分布式环境下,其实已经很少使用Spring自带的定时器了,而使用分布式任务调度框架:Elastic-jobxxl-job

另外说几点使用细节:

  1. 标注@Scheduled注解的方法必须无入数
  2. cron、fixedDelay、fixedRate注解属性必须至少一个
  3. 若在分布式环境(或者集群环境)直接使用Spring的Scheduled,请使用分布式锁或者保证任务的幂等

网上有一个谣言:说@Schedule若发生异常后,后面该任务就死掉了不会再执行了。如果看了本文分析的原理,显然就不攻自破了。结论:抛出异常后任务还是会执行的

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏业余草

面试必考的网络编程知识,帮你梳理好了

原文链接:https://time.geekbang.org/column/intro/100032701?code=...

12820
来自专栏HACK学习

Windows远程执行cmd命令的9种方法

IPC$+AT 445 PSEXEC 445 WMI 135 Winrm 5985(HTTP)&5986(HTTPS)

3K10
来自专栏Super 前端

Git汇总--常见问题及延伸阅读

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。

7930
来自专栏业余草

用 Linux 下所有的压缩、解压命令造轮子

5G 来了,5G 是未来的一个驱动力。比 5G 更重要的一个是 AI,我们赢了 5G,并不代表我们赢了未来。

8530
来自专栏云服务器教程

自定义配置 Linux 云服务器

与快速配置云服务器相比,自定义配置提供您更丰富的镜像平台,以及存储、带宽以及安全组等高级设置,您可根据需求选择合适的配置。

26650
来自专栏机器人课程与技术

机器人操作系统二(ROS2)- 启程 Departure

是时候放下ROS1,开启ROS2的旅程了。It's time to put down ROS1 and start the journey of ROS2.

33620
来自专栏机器人课程与技术

Cozmo机器人之ROS和AI体验(训练)营-2019-ROS暑期学校

版权声明:署名,允许他人基于本文进行创作,且必须基于与原先许可协议相同的许可协议分发本文 (Creative Commons)

8720
来自专栏白安全组

Linux入侵小结

Linux不同的用户,有不同的操作权限,但是所有用户都会在/etc/passwd /etc/shadow /etc/group /etc/group- 文件中记...

33420
来自专栏牛客网

测试方面的面试复盘

先说结论,基础必须要打牢固,能自己做总结最好,面试时要主动,不要紧张,要珍惜内推机会。

13310
来自专栏量子位

一键完成室内设计:哈佛学霸造出ArchiGAN,房间规划家具摆放全都有,Demo可玩

这就是法国小哥 Stanislas Chaillou 产出的一只设计GAN,名字叫ArchiGAN。

21120

扫码关注云+社区

领取腾讯云代金券

年度创作总结 领取年终奖励