@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;
	}
    //每五秒執(zhí)行一次。
	@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實現(xiàn)了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.  重點就是這個。發(fā)布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;
		}
		//得到?jīng)]有被裝飾的最原始的類，就是cglib增強之前的原始的類，并且這里也能說明CGLib是通過繼承來實現(xiàn)增強的
		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 {
			//斷言，判單方法是否有參數(shù)，如果有參數(shù)就報錯
			Assert.isTrue(method.getParameterCount() == 0, "Only no-arg methods may be annotated with @Scheduled");//這里會判斷 getParameterCount==0，如果不是0的話，就報錯。這也是spring里面定時任務比較雞肋的方法，但是這個我覺得并沒有啥子問題，誰在定時任務執(zhí)行的時候需要傳遞參數(shù)
			//判斷這個方法是否是靜態(tài)，私有的，
			Method invocableMethod = AopUtils.selectInvocableMethod(method, bean.getClass());
			//將需要執(zhí)行的方法封裝成ScheduledMethodRunnable，這個類實現(xiàn)很簡單，就倆屬性，
			//target表示bean
			//method表示需要執(zhí)行的方法
			Runnable runnable = new ScheduledMethodRunnable(bean, invocableMethod);
			//標志位，開始都是false，只要找到@Scheduled注解，并且解析到參數(shù)，就是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處理器很常見，會從環(huán)境中替換值
					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之后，標志位變?yōu)閠rue
					processedSchedule = true;
					TimeZone timeZone;
					if (StringUtils.hasText(zone)) {
						timeZone = StringUtils.parseTimeZoneString(zone);
					}
					else {
						timeZone = TimeZone.getDefault();
					}
					//將cron表達式變?yōu)镃ronTrigger，
					//將runnable（ScheduledMethodRunnable）變?yōu)镃ronTask
					//將CronTask變?yōu)閟cheduleCronTask，并且將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里面必須的參數(shù)是否都有
			Assert.isTrue(processedSchedule, errorMessage);
			//在解析完成之后，將bean和@schedule保存在map里面，map的key是bean，value是set，set存放的是這個bean里面被@schedule標注方法的集合，
			// 也就是ScheduledTask集合
			//但是這里的加鎖操作，我沒有看懂，不知道這個是干嘛的？
			//這里會有并發(fā)的問題嗎？首先他是在postProcessAfterInitialization方法里面起作用的，這個方法在spring解析bean的時候起作用的
			//并且spring調用beanPostProcess都是順序調用。不存在并發(fā)問題。
			// 所以這里的鎖，我沒有看懂。
			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的實現(xiàn)類，也沒有ScheduledExecutorService的實現(xiàn)類，那就自己默認來一個，
		//  Executors.newSingleThreadScheduledExecutor(); 核心線程是1，但是最大線程數(shù)是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) {
   //得到執(zhí)行器
   //關于這個執(zhí)行器的參數(shù)的設置可以看ExecutorConfigurationSupport，
   ScheduledExecutorService executor = getScheduledExecutor();
   try {
      //錯誤處理的handle。有兩種handle，一種是出錯了之后打印日志，一種是拋異常
      // LoggingErrorHandler
      // PropagatingErrorHandler
      ErrorHandler errorHandler = this.errorHandler;
      if (errorHandler == null) {
         errorHandler = TaskUtils.getDefaultErrorHandler(true);
      }
      //將執(zhí)行器，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) {
			//獲取下次任務執(zhí)行的事件
			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方法
		//并且這里也有執(zhí)行失敗之后的異常處理
		super.run();
		Date completionTime = new Date();
		synchronized (this.triggerContextMonitor) {
			//scheduledExecutionTime這個不是null，因為在調用的時候是先調用schedule方法的，在這個方法里面設置了scheduledExecutionTime（下次執(zhí)行的時間）
			Assert.state(this.scheduledExecutionTime != null, "No scheduled execution");
			//更新triggerContext，triggerContext是在這個類里面直接new出來的
			//上次執(zhí)行時間，上次執(zhí)行的耗費的真正時間，完成任務時間
			this.triggerContext.update(this.scheduledExecutionTime, actualExecutionTime, completionTime);
			if (!obtainCurrentFuture().isCancelled()) {
				//繼續(xù)調用schedule，這就是精髓，今天的重點。繼續(xù)注冊，繼續(xù)循環(huán)，
				schedule();
			}
		}
	}