Spring定时任务关于@EnableScheduling的用法解析

@Configuration
@EnableScheduling
public class MainApplicationBootStrap {
	@Bean
	public Bride bride(){
		return new Bride();
	}
	public static void main(String[] args) throws IOException {
		AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext("com.lc.spring");
		Bride bride = annotationConfigApplicationContext.getBean(Bride.class);
		System.out.println(bride);
		System.in.read();
	}
}
//Bride类
public class Bride {
	private String name;
	private int count;
	private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd : HH mm ss");
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
    //每五秒执行一次。
	@Scheduled(cron = "0/5 * * * * ?")
	public void sayHello2(){
		System.out.println(simpleDateFormat.format(new Date())  + ":"  +  Thread.currentThread().getName()  + "： "+ Bride.class.getName() + ": say hello2 " + count++ );
	}
}

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

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE) //spring里面自己用得bean，和用户自定没有关系
public class SchedulingConfiguration {
	@Bean(name = TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() {
		return new ScheduledAnnotationBeanPostProcessor();
	}
}

//在实例化出来之后，在调用postProcessAfterInitialization之前会调用postProcessMergedBeanDefinition。
void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
//初始化之前
@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
//重点是这个方法。等会看看在ScheduledAnnotationBeanPostProcessor里面干了什么事情。
@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;
default boolean requiresDestruction(Object bean) {
		return true;
	}

//在所有的bean实例化完成之后，如果bean实现了SmartInitializingSingleton接口，就会调用afterSingletonsInstantiated方法。
void afterSingletonsInstantiated()

------------------------refresh方法
// Last step: publish corresponding event.
				finishRefresh();
------------------------下面是finishRefresh具体的内容。
/**
	 * Finish the refresh of this context, invoking the LifecycleProcessor's
	 * onRefresh() method and publishing the
	 * {@link org.springframework.context.event.ContextRefreshedEvent}.
	 */
	protected void finishRefresh() {
		// Clear context-level resource caches (such as ASM metadata from scanning).
		clearResourceCaches();
		// Initialize lifecycle processor for this context.  初始化 LifecycleProcessor
		initLifecycleProcessor();
		// Propagate refresh to lifecycle processor first. 
		getLifecycleProcessor().onRefresh();
		// Publish the final event.  重点就是这个。发布ContextRefreshedEvent事件，表示活都干完了。
		publishEvent(new ContextRefreshedEvent(this));
		// Participate in LiveBeansView MBean, if active.
		LiveBeansView.registerApplicationContext(this);
	}

@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		if (bean instanceof AopInfrastructureBean) {
			// Ignore AOP infrastructure such as scoped proxies.
			return bean;
		}
		//得到没有被装饰的最原始的类，就是cglib增强之前的原始的类，并且这里也能说明CGLib是通过继承来实现增强的
		Class<?> targetClass = AopProxyUtils.ultimateTargetClass(bean);
		if (!this.nonAnnotatedClasses.contains(targetClass)) {
			Map<Method, Set<Scheduled>> annotatedMethods = MethodIntrospector.selectMethods(targetClass,//找处了所有的被Scheduled标注的方法
					(MethodIntrospector.MetadataLookup<Set<Scheduled>>) method -> {
						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: " + targetClass);
				}
			}
			else {
				// Non-empty set of methods
				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");//这里会判断 getParameterCount==0，如果不是0的话，就报错。这也是spring里面定时任务比较鸡肋的方法，但是这个我觉得并没有啥子问题，谁在定时任务执行的时候需要传递参数
			//判断这个方法是否是静态，私有的，
			Method invocableMethod = AopUtils.selectInvocableMethod(method, bean.getClass());
			//将需要执行的方法封装成ScheduledMethodRunnable，这个类实现很简单，就俩属性，
			//target表示bean
			//method表示需要执行的方法
			Runnable runnable = new ScheduledMethodRunnable(bean, invocableMethod);
			//标志位，开始都是false，只要找到@Scheduled注解，并且解析到参数，就是false，后面还会对他进行判断。
			boolean processedSchedule = false;
			String errorMessage =
					"Exactly one of the 'cron', 'fixedDelay(String)', or 'fixedRate(String)' attributes is required";
			//存放组装好的ScheduledTask，
			Set<ScheduledTask> tasks = new LinkedHashSet<>(4);
			//判断initialDelay
			long initialDelay = scheduled.initialDelay();
			String initialDelayString = scheduled.initialDelayString();
			if (StringUtils.hasText(initialDelayString)) {
				Assert.isTrue(initialDelay < 0, "Specify 'initialDelay' or 'initialDelayString', not both");
				//这里的initialDelayString就是后面的这个样子    "PT20.345S" -- parses as "20.345 seconds" "PT15M"     -- parses as "15 minutes" (where a minute is 60
				if (this.embeddedValueResolver != null) {
					//这个意味着，这里的initialDelayString是可以写SPEL表达式的。embeddedValueResolver处理器很常见，会从环境中替换值
					initialDelayString = this.embeddedValueResolver.resolveStringValue(initialDelayString);
				}
				if (StringUtils.hasLength(initialDelayString)) {
					try {//最后还是得解析成initialDelay。
						initialDelay = parseDelayAsLong(initialDelayString);
					}
					catch (RuntimeException ex) {
						throw new IllegalArgumentException(
								"Invalid initialDelayString value \"" + initialDelayString + "\" - cannot parse into long");
					}
				}
			}
			//检查cron表达式
			String cron = scheduled.cron();
			if (StringUtils.hasText(cron)) {
				String zone = scheduled.zone();
				if (this.embeddedValueResolver != null) {//这里也能处理
					//事实就是这样，利用embeddedValueResolver来处理值，很巧妙。
					cron = this.embeddedValueResolver.resolveStringValue(cron);
					zone = this.embeddedValueResolver.resolveStringValue(zone);
				}
				if (StringUtils.hasLength(cron)) {
					Assert.isTrue(initialDelay == -1, "'initialDelay' not supported for cron triggers");
					//解析到cron之后，标志位变为true
					processedSchedule = true;
					TimeZone timeZone;
					if (StringUtils.hasText(zone)) {
						timeZone = StringUtils.parseTimeZoneString(zone);
					}
					else {
						timeZone = TimeZone.getDefault();
					}
					//将cron表达式变为CronTrigger，
					//将runnable（ScheduledMethodRunnable）变为CronTask
					//将CronTask变为scheduleCronTask，并且将CronTask添加到 registrar的cronTasks属性去，并还维护了CronTask和scheduleCronTask的映射关系。
					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;
			}
	       .........省略部分代码.......这些代码和上面的cron都是一样的，不同的是task的类型不同。其余都是一样的。
			// Check whether we had any attribute set 检查一下，检查是@schedule里面必须的参数是否都有
			Assert.isTrue(processedSchedule, errorMessage);
			//在解析完成之后，将bean和@schedule保存在map里面，map的key是bean，value是set，set存放的是这个bean里面被@schedule标注方法的集合，
			// 也就是ScheduledTask集合
			//但是这里的加锁操作，我没有看懂，不知道这个是干嘛的？
			//这里会有并发的问题吗？首先他是在postProcessAfterInitialization方法里面起作用的，这个方法在spring解析bean的时候起作用的
			//并且spring调用beanPostProcess都是顺序调用。不存在并发问题。
			// 所以这里的锁，我没有看懂。
			synchronized (this.scheduledTasks) {
				Set<ScheduledTask> regTasks = this.scheduledTasks.computeIfAbsent(bean, key -> new LinkedHashSet<>(4));
				regTasks.addAll(tasks);
			}
		}
		catch (IllegalArgumentException ex) {
			throw new IllegalStateException(
					"Encountered invalid @Scheduled method '" + method.getName() + "': " + ex.getMessage());
		}
	}

private final Task task;//任务
    //保留的是ScheduledFuture的引用，ScheduledFuture是scheduledExecutorService提交任务之后的引用对象。
	//ScheduledFuture<?> scheduledFuture = scheduledExecutorService.scheduleWithFixedDelay(() -> {
	//	}, 0, 0, TimeUnit.SECONDS);
	@Nullable
	volatile ScheduledFuture<?> future;

@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {
		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).
			finishRegistration();
		}
	}

protected void scheduleTasks() {
		//如果说在spring中没有 TaskScheduler的实现类，也没有ScheduledExecutorService的实现类，那就自己默认来一个，
		//  Executors.newSingleThreadScheduledExecutor(); 核心线程是1，但是最大线程数是Max。
		// 通过ConcurrentTaskScheduler包装。
		if (this.taskScheduler == null) {
			this.localExecutor = Executors.newSingleThreadScheduledExecutor();
			this.taskScheduler = new ConcurrentTaskScheduler(this.localExecutor);
		}
		//下面就是挨个从之前注册的这些task里面从 ScheduledTaskRegistrar里面维护的双向映射关系中获取scheduledTask，通过
		//  ScheduledTaskRegistrar中的taskScheduled提交任务，将返回的Future对象保存在ScheduledTask引用里面。
		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));
			}
		}
	}

//首先这个方法是ScheduledTaskRegistrar的	
@Nullable
	public ScheduledTask scheduleCronTask(CronTask task) {
        //之前保存在解析schedule的时候保存的CronTask和ScheduledTask之前的引用关系。
		ScheduledTask scheduledTask = this.unresolvedTasks.remove(task);
		boolean newTask = false;
        //这里肯定是有的，所以，肯定不会从这里走，所以newTask肯定是fasle，那这个方法的返回值肯定是null
		if (scheduledTask == null) {
			scheduledTask = new ScheduledTask(task);
			newTask = true;
		}
        //提交任务
		if (this.taskScheduler != null) {
            //提交任务，接下来就看看taskScheduler相关的就好了
			scheduledTask.future = this.taskScheduler.schedule(task.getRunnable(), task.getTrigger());
		}
		else {
			addCronTask(task);
			this.unresolvedTasks.put(task, scheduledTask);
		}
		return (newTask ? scheduledTask : null);
	}

@Override
@Nullable
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
   //得到执行器
   //关于这个执行器的参数的设置可以看ExecutorConfigurationSupport，
   ScheduledExecutorService executor = getScheduledExecutor();
   try {
      //错误处理的handle。有两种handle，一种是出错了之后打印日志，一种是抛异常
      // LoggingErrorHandler
      // PropagatingErrorHandler
      ErrorHandler errorHandler = this.errorHandler;
      if (errorHandler == null) {
         errorHandler = TaskUtils.getDefaultErrorHandler(true);
      }
      //将执行器，task，trigger包装成ReschedulingRunnable，schedule方法通过将这个任务提交给executor，但是这里写的很巧妙
      return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();
   }
   catch (RejectedExecutionException ex) {
      throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
   }
}

RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.AbortPolicy();

return getThreadNamePrefix() + this.threadCount.incrementAndGet();

return ClassUtils.getShortName(getClass()) + "-";

corePoolSize=1
maximumPoolSize = MAX_VALUE
ttl=0
queue=new DelayedWorkQueue(), //这是xecutor默认的队列

@Nullable
	public ScheduledFuture<?> schedule() {
		synchronized (this.triggerContextMonitor) {
			//获取下次任务执行的事件
			this.scheduledExecutionTime = this.trigger.nextExecutionTime(this.triggerContext);
			if (this.scheduledExecutionTime == null) {
				return null;
			}
			//算出需要延迟启动的事件
			long initialDelay = this.scheduledExecutionTime.getTime() - System.currentTimeMillis();
			//延迟启动，提交给executor的schedule
			this.currentFuture = this.executor.schedule(this, initialDelay, TimeUnit.MILLISECONDS);
			return this;
		}
	}

@Override
	public void run() {
		Date actualExecutionTime = new Date();
		//开始跑任务，这里是通过反射调用的，
		//要知道这里的runnable是ScheduledMethodRunnable对象，反射调用就在ScheduledMethodRunnable里面的run方法
		//并且这里也有执行失败之后的异常处理
		super.run();
		Date completionTime = new Date();
		synchronized (this.triggerContextMonitor) {
			//scheduledExecutionTime这个不是null，因为在调用的时候是先调用schedule方法的，在这个方法里面设置了scheduledExecutionTime（下次执行的时间）
			Assert.state(this.scheduledExecutionTime != null, "No scheduled execution");
			//更新triggerContext，triggerContext是在这个类里面直接new出来的
			//上次执行时间，上次执行的耗费的真正时间，完成任务时间
			this.triggerContext.update(this.scheduledExecutionTime, actualExecutionTime, completionTime);
			if (!obtainCurrentFuture().isCancelled()) {
				//继续调用schedule，这就是精髓，今天的重点。继续注册，继续循环，
				schedule();
			}
		}
	}