用内部定时器0中断的计数器，问题出在什么地方？
本回答由提问者推荐
var sogou_ad_id=731547;
var sogou_ad_height=160;
var sogou_ad_width=690;<h3 class="form-title" data-v-6b秒快速估算装修报价㎡立即计算家里用墙纸好吗？wduser_很好 比乳胶好多了更多回答soullzhang墙纸好看，显得温馨，但是不耐用。wduser_我是专业做墙纸的，墙纸漂亮，温馨，大方，高档，而且耐磨好擦洗，环保。如果选用花纸，国产价位大概在80-200之间/5平方/卷，一般的素色纸，随便用用也比乳胶漆好看，国产价位在60-200元/5平方/卷，进口品的价位一般在300元以上。例如地面面积在15平方的话，一般用量在9卷至10卷，算一下价格不比乳胶漆贵多少，有的甚至还便宜，可做出的效果却比乳胶漆出彩百倍。关于弊端当然也有，不过不太影响我们的生活。要看你选用什么材质的壁纸，如果是我上述的价位一般都是胶面的，其不是纯环保的，但是符合环保要求的，优点是易于打理，有肌理，花色丰富，接缝不明显。如果你肯多花点钱也可以买些其他的材质，例如无纺布，无纺纸，纸质，纱线或者编织壁布等，价位基本上在200元以上/支，其优点是纯环保，但不易于打理，花色较单调。纸质的接缝明显。但从更多的效果方面去考虎，肯定墙纸好看，而且房子住上个十年八年也不会像乳胶漆墙那样这儿黑一块，那儿脏一块的。犯黄易脏，又不能打理。我家有两间房子，一间贴有墙纸一间没贴，四年住下来，我的房间像新的，另外一间像住了十年的感觉。另外有小孩，喜欢乱画，如果选用胶面的壁纸还可以用洗洁精或者刷子清洗，所以很方便。
另装修选用什么样的墙纸关键看你装修的风格，依装修的风格不同选用不同需求的壁纸。例如现代风格你可以选用纸质的、无纺布的、胶面的、纱线壁布等等，如果是欧式的风格当然胶面壁纸更能体现，因为其肌理效果好，压纹较深，奢华。当然也要有预算，现在市场上家用的墙纸从20元/平方到2000元/平方不等，再看你的心理预算去选用自己喜欢的产品。家用，要选用环保的，有品牌的产品，使用放心，服务也好。
乳胶漆很多都是进口产品，然而一些欧美国家和日本这些发达的国家，墙纸的普及率达到90%以上，而在中国大量的乳胶漆进入市场，这说明了什么？一是流行趋势，二是乳胶漆并不像说得那么环保，否则一向崇尚环保的美国和日本为什么乳胶漆的使用率如此低呢？
一般墙纸的正常使用寿命在7-8年是肯定没有任何问题的，而且也不会显得那么脏，可是乳胶漆你试试，刷上三年以后再看看，肯定到处都是手印，污点等等，无论是从美观还是环保再到使用寿命及价位来讲，我都推荐你选用墙纸。因为我有自己家的实践证明。
另附风格简介供你参考：
欧式，可以看一些欧洲的建筑风格，其壁纸也会有一些类似的元素，例如大马士革的图案，欧式铁艺图案等等。色彩主要以黄色或者金黄色或者宝蓝色等等。
现代，就是一些现代的元素，例如几何图型，流线型的图案，还有一些现代的花艺等，色彩的话以黑白灰红等等比较跳跃的色彩为主。
东南亚风格，主要是以热带雨林的感觉为主题的格调，麻布纹、藤编织、镂空图案等等，色彩比较大胆出挑，类似少数民族的多色性。
美式，分为美式田园乡村风格和美式传统风格。乡村风格主要是以花壁纸为主，传统风格的话和欧式风格有些相似，但与传统欧式的风格相比，会有些作旧的成分在里面，而且不会那么奢华，看起来比较有创意的一些图案。
地中海风格，主要会有一些以海为背景或者海产品为元素的图案。地中海风格会有拱形的门或者窗等。色彩基本都会有一些蓝色的基调，元素会有海贝壳、沙粒或者石子等等。
爵士风格，某种意义上说是新古典的风格，介于现代与欧式古典之间。图案比欧式的简约一些。色彩比较现代，一般以黑色、灰色等深色调为主。
原创回答，希望能帮到你。wduser_我感觉 也 不错。。你那些人美眼光热门问答1234567891011121314151617181920查看更多21222324252627282930测黄道吉日抢平台优惠价格从低到高
价格从高到低
相关推荐词
相关推荐词
相关推荐词
相关推荐词
相关推荐词
[{"chanpin":"tmall","mobileUrl":"https://m.tmall.com/mblist/cp_tqjWxrXnt7m5-A==.html","pcUrl":"https://www.tmall.com/mlist/cp_tqjWxrXnt7m5-A==.html","word":"定制电饭锅"}]spring配置文件中配置
&?xml version="1.0" encoding="UTF-8"?&
&beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.0.xsd"&
&bean class="com.wjz.quartz.RepayQuartz"/&
&task:annotation-driven/&&/beans&
定时任务处理类
package com.wjz.
import org.springframework.scheduling.annotation.Spublic class RepayQuartz {
@Scheduled(cron="0/10 * * * * ?")
public void repay() {
System.out.println("sping 定时任务");
&task:annotation-driven/&标签使用TaskNamespaceHandler&来处理
public class TaskNamespaceHandler extends NamespaceHandlerSupport {
public void init() {　　　　　// 注册了一些解析器其中AnnotationDrivenBeanDefinitionParser解析@Scheduled注解
this.registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
this.registerBeanDefinitionParser("executor", new ExecutorBeanDefinitionParser());
this.registerBeanDefinitionParser("scheduled-tasks", new ScheduledTasksBeanDefinitionParser());
this.registerBeanDefinitionParser("scheduler", new SchedulerBeanDefinitionParser());
注册了两个后置处理器
org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor
org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor
我们主要来看ScheduledAnnotationBeanPostProcessor
我们可以看到他实现了BeanPostProcesser，ApplicationListener接口
先执行初始化后的后置处理
public Object postProcessAfterInitialization(final Object bean, String beanName) {
Class&?& targetClass = AopUtils.getTargetClass(bean);
if (!this.nonAnnotatedClasses.contains(targetClass)) {　　　　　　　// 获得bean的所有的方法，获得方法信息和@Scheduled注解信息
Map&Method, Set&Scheduled&& annotatedMethods = MethodIntrospector.selectMethods(targetClass,
new MethodIntrospector.MetadataLookup&Set&Scheduled&&() {
public Set&Scheduled& inspect(Method 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: " + bean.getClass());
for (Map.Entry&Method, Set&Scheduled&& entry : annotatedMethods.entrySet()) {
Method method = entry.getKey();
for (Scheduled scheduled : entry.getValue()) {　　　　　　　　　　　　　　 // 处理加工方法和注解信息，后文详解
processScheduled(scheduled, method, bean);
if (logger.isDebugEnabled()) {
logger.debug(annotatedMethods.size() + " @Scheduled methods processed on bean '" + beanName +
"': " + annotatedMethods);
protected void processScheduled(Scheduled scheduled, Method method, Object bean) {
Method invocableMethod = AopUtils.selectInvocableMethod(method, bean.getClass());　　　　　　　// 创建了一个Runnable对象，主要是用来反射定时方法的，后文详解#1
Runnable runnable = new ScheduledMethodRunnable(bean, invocableMethod);
boolean processedSchedule = false;
String errorMessage =
"Exactly one of the 'cron', 'fixedDelay(String)', or 'fixedRate(String)' attributes is required";
　　　　　　　 // 初始化一个定时任务集合
Set&ScheduledTask& tasks = this.scheduledTasks.get(bean);
if (tasks == null) {
tasks = new LinkedHashSet&ScheduledTask&(4);
this.scheduledTasks.put(bean, tasks);
// Determine initial delay
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);
initialDelay = Long.parseLong(initialDelayString);
catch (NumberFormatException ex) {
throw new IllegalArgumentException(
"Invalid initialDelayString value \"" + initialDelayString + "\" - cannot parse into integer");
// 解析表达式
String cron = scheduled.cron();
if (StringUtils.hasText(cron)) {
Assert.isTrue(initialDelay == -1, "'initialDelay' not supported for cron triggers");
processedSchedule = true;
String zone = scheduled.zone();
if (this.embeddedValueResolver != null) {
cron = this.embeddedValueResolver.resolveStringValue(cron);
zone = this.embeddedValueResolver.resolveStringValue(zone);
TimeZone timeZ
if (StringUtils.hasText(zone)) {
timeZone = StringUtils.parseTimeZoneString(zone);
else {　　　　　　　　　　　　// 没有指定时区的话使用默认时区
timeZone = TimeZone.getDefault();
}　　　　　　　　　 // 将表达式解析成任务计划表填充到任务集合中，后文详解#2
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;
// Check fixed delay
long fixedDelay = scheduled.fixedDelay();
if (fixedDelay &= 0) {
Assert.isTrue(!processedSchedule, errorMessage);
processedSchedule = true;
tasks.add(this.registrar.scheduleFixedDelayTask(new IntervalTask(runnable, fixedDelay, initialDelay)));
String fixedDelayString = scheduled.fixedDelayString();
if (StringUtils.hasText(fixedDelayString)) {
Assert.isTrue(!processedSchedule, errorMessage);
processedSchedule = true;
if (this.embeddedValueResolver != null) {
fixedDelayString = this.embeddedValueResolver.resolveStringValue(fixedDelayString);
fixedDelay = Long.parseLong(fixedDelayString);
catch (NumberFormatException ex) {
throw new IllegalArgumentException(
"Invalid fixedDelayString value \"" + fixedDelayString + "\" - cannot parse into integer");
tasks.add(this.registrar.scheduleFixedDelayTask(new IntervalTask(runnable, fixedDelay, initialDelay)));
// Check fixed rate
long fixedRate = scheduled.fixedRate();
if (fixedRate &= 0) {
Assert.isTrue(!processedSchedule, errorMessage);
processedSchedule = true;
tasks.add(this.registrar.scheduleFixedRateTask(new IntervalTask(runnable, fixedRate, initialDelay)));
String fixedRateString = scheduled.fixedRateString();
if (StringUtils.hasText(fixedRateString)) {
Assert.isTrue(!processedSchedule, errorMessage);
processedSchedule = true;
if (this.embeddedValueResolver != null) {
fixedRateString = this.embeddedValueResolver.resolveStringValue(fixedRateString);
fixedRate = Long.parseLong(fixedRateString);
catch (NumberFormatException ex) {
throw new IllegalArgumentException(
"Invalid fixedRateString value \"" + fixedRateString + "\" - cannot parse into integer");
tasks.add(this.registrar.scheduleFixedRateTask(new IntervalTask(runnable, fixedRate, initialDelay)));
// Check whether we had any attribute set
Assert.isTrue(processedSchedule, errorMessage);
catch (IllegalArgumentException ex) {
throw new IllegalStateException(
"Encountered invalid @Scheduled method '" + method.getName() + "': " + ex.getMessage());
书接前文#1
Runnable的run方法中是定时方法反射
public void run() {
ReflectionUtils.makeAccessible(this.method);
this.method.invoke(this.target);
catch (InvocationTargetException ex) {
ReflectionUtils.rethrowRuntimeException(ex.getTargetException());
catch (IllegalAccessException ex) {
throw new UndeclaredThrowableException(ex);
书接前文#2
创建一个CronTask任务对象，其中有Runnable对象和CronTrigger触发对象（表达式，时区），后文详解触发器的构造#2-1
public ScheduledTask scheduleCronTask(CronTask task) {
ScheduledTask scheduledTask = this.unresolvedTasks.remove(task);
boolean newTask = false;
if (scheduledTask == null) {
scheduledTask = new ScheduledTask();
newTask = true;
if (this.taskScheduler != null) {　　　　　　　 // 执行定时任务
scheduledTask.future = this.taskScheduler.schedule(task.getRunnable(), task.getTrigger());
else {　　　　　　　 // 添加定时任务
addCronTask(task);
this.unresolvedTasks.put(task, scheduledTask);
return (newTask ? scheduledTask : null);
再看监听处理
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();
this.registrar.afterPropertiesSet();
protected void scheduleTasks() {
if (this.taskScheduler == null) {　　　　　　　 // 初始化一个线程池调度器
this.localExecutor = Executors.newSingleThreadScheduledExecutor();　　　　　　　 // 指定了任务调度器
this.taskScheduler = new ConcurrentTaskScheduler(this.localExecutor);
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));
public ScheduledTask scheduleCronTask(CronTask task) {
ScheduledTask scheduledTask = this.unresolvedTasks.remove(task);
boolean newTask = false;
if (scheduledTask == null) {
scheduledTask = new ScheduledTask();
newTask = true;
}　　　　　// 这次指定了ConcurrentTaskScheduler任务调度器，开始调度定时任务
if (this.taskScheduler != null) {
scheduledTask.future = this.taskScheduler.schedule(task.getRunnable(), task.getTrigger());
addCronTask(task);
this.unresolvedTasks.put(task, scheduledTask);
return (newTask ? scheduledTask : null);
public ScheduledFuture&?& schedule(Runnable task, Trigger trigger) {
if (this.enterpriseConcurrentScheduler) {
return new EnterpriseConcurrentTriggerScheduler().schedule(decorateTask(task, true), trigger);
ErrorHandler errorHandler = (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));　　　　　　　　　 // 这里就是核心的地方了， Runnable的run方法内，定时调用自己的run方法实现功能，巧妙之极
return new ReschedulingRunnable(task, trigger, this.scheduledExecutor, errorHandler).schedule();
catch (RejectedExecutionException ex) {
throw new TaskRejectedException("Executor [" + this.scheduledExecutor + "] did not accept task: " + task, ex);
public ScheduledFuture&?& schedule() {
synchronized (this.triggerContextMonitor) {　　　　　　　 // 拿到下一次执行任务的时间，后文详解#2-2
this.scheduledExecutionTime = this.trigger.nextExecutionTime(this.triggerContext);
if (this.scheduledExecutionTime == null) {
return null;
}　　　　　　　 // 固定延迟即延迟多长时间执行
long initialDelay = this.scheduledExecutionTime.getTime() - System.currentTimeMillis();
this.currentFuture = this.executor.schedule(this, initialDelay, TimeUnit.MILLISECONDS);
return this;
public void run() {
Date actualExecutionTime = new Date();　　　　　// 这就是上文所提到的定时方法反射执行定时业务方法
super.run();
Date completionTime = new Date();
synchronized (this.triggerContextMonitor) {　　　　　　　 // 记录上一次任务执行的时间
this.triggerContext.update(this.scheduledExecutionTime, actualExecutionTime, completionTime);
if (!this.currentFuture.isCancelled()) {　　　　　　　　　 // 继续无限调度
schedule();
&书接前文#2-1
CronTrigger触发对象的构造，初始化了计划时间表生成器
public CronTrigger(String expression, TimeZone timeZone) {
this.sequenceGenerator = new CronSequenceGenerator(expression, timeZone);
public CronSequenceGenerator(String expression, TimeZone timeZone) {
this.expression =
this.timeZone = timeZ　　　　　// 解析表达式生成计划时间表
parse(expression);
private void parse(String expression) throws IllegalArgumentException {
String[] fields = StringUtils.tokenizeToStringArray(expression, " ");
if (!areValidCronFields(fields)) {
throw new IllegalArgumentException(String.format(
"Cron expression must consist of 6 fields (found %d in \"%s\")", fields.length, expression));
}　　　　　// 主要使用了BitSet来制造计划时间表
setNumberHits(this.seconds, fields[0], 0, 60);
setNumberHits(this.minutes, fields[1], 0, 60);
setNumberHits(this.hours, fields[2], 0, 24);
setDaysOfMonth(this.daysOfMonth, fields[3]);
setMonths(this.months, fields[4]);
setDays(this.daysOfWeek, replaceOrdinals(fields[5], "SUN,MON,TUE,WED,THU,FRI,SAT"), 8);
if (this.daysOfWeek.get(7)) {
// Sunday can be represented as 0 or 7
this.daysOfWeek.set(0);
this.daysOfWeek.clear(7);
private void setNumberHits(BitSet bits, String value, int min, int max) {
String[] fields = StringUtils.delimitedListToStringArray(value, ",");
for (String field : fields) {　　　　　　　// 检查是否包含'/',不包含的话列出最小值到最大值的范围
if (!field.contains("/")) {
// Not an incrementer so it must be a range (possibly empty)
int[] range = getRange(field, min, max);
bits.set(range[0], range[1] + 1);
// 包含'/'的话列出每xx秒（或分、时）的时间表如{0,10,20,30,40,50}
String[] split = StringUtils.delimitedListToStringArray(field, "/");
if (split.length & 2) {
throw new IllegalArgumentException("Incrementer has more than two fields: '" +
field + "' in expression \"" + this.expression + "\"");
int[] range = getRange(split[0], min, max);
if (!split[0].contains("-")) {
range[1] = max - 1;
int delta = Integer.valueOf(split[1]);
if (delta &= 0) {
throw new IllegalArgumentException("Incrementer delta must be 1 or higher: '" +
field + "' in expression \"" + this.expression + "\"");
}　　　　　　　　　 // 以一定数值叠加为BitSet赋值
for (int i = range[0]; i &= range[1]; i += delta) {
bits.set(i);
private int[] getRange(String field, int min, int max) {
int[] result = new int[2];　　　　　// 包含*就是最大到最小
if (field.contains("*")) {
result[0] =
result[1] = max - 1;
}　　　　　// 不包含'/'和'-'返回值
if (!field.contains("-")) {
result[0] = result[1] = Integer.valueOf(field);
String[] split = StringUtils.delimitedListToStringArray(field, "-");
if (split.length & 2) {
throw new IllegalArgumentException("Range has more than two fields: '" +
field + "' in expression \"" + this.expression + "\"");
result[0] = Integer.valueOf(split[0]);
result[1] = Integer.valueOf(split[1]);
if (result[0] &= max || result[1] &= max) {
throw new IllegalArgumentException("Range exceeds maximum (" + max + "): '" +
field + "' in expression \"" + this.expression + "\"");
if (result[0] & min || result[1] & min) {
throw new IllegalArgumentException("Range less than minimum (" + min + "): '" +
field + "' in expression \"" + this.expression + "\"");
if (result[0] & result[1]) {
throw new IllegalArgumentException("Invalid inverted range: '" + field +
"' in expression \"" + this.expression + "\"");
书接前文#2-2
拿到下一个执行调度的时间
public Date nextExecutionTime(TriggerContext triggerContext) {　　　　　// 拿到上一次执行调度的时间
Date date = triggerContext.lastCompletionTime();
if (date != null) {
Date scheduled = triggerContext.lastScheduledExecutionTime();
if (scheduled != null && date.before(scheduled)) {
else {　　　　　　　 // 没拿到的话就拿当前时间
date = new Date();
}　　　　　// 拿到一下一次执行调度的时间
return this.sequenceGenerator.next(date);
public Date next(Date date) {
Calendar calendar = new GregorianCalendar();
calendar.setTimeZone(this.timeZone);
calendar.setTime(date);
calendar.set(Calendar.MILLISECOND, 0);
long originalTimestamp = calendar.getTimeInMillis();　　　　　// 为日历设置下一次执行调度的时间
doNext(calendar, calendar.get(Calendar.YEAR));
if (calendar.getTimeInMillis() == originalTimestamp) {
calendar.add(Calendar.SECOND, 1);
doNext(calendar, calendar.get(Calendar.YEAR));
　　　　　// 返回设置好下一次调度的日历时间
return calendar.getTime();
private void doNext(Calendar calendar, int dot) {
List&Integer& resets = new ArrayList&Integer&();
　　　　　// 拿到当前时间的秒数
int second = calendar.get(Calendar.SECOND);
List&Integer& emptyList = Collections.emptyList();　　　　　// 拿到下一次执行调度的秒数
int updateSecond = findNext(this.seconds, second, calendar, Calendar.SECOND, Calendar.MINUTE, emptyList);
if (second == updateSecond) {
resets.add(Calendar.SECOND);
int minute = calendar.get(Calendar.MINUTE);
int updateMinute = findNext(this.minutes, minute, calendar, Calendar.MINUTE, Calendar.HOUR_OF_DAY, resets);
if (minute == updateMinute) {
resets.add(Calendar.MINUTE);
doNext(calendar, dot);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int updateHour = findNext(this.hours, hour, calendar, Calendar.HOUR_OF_DAY, Calendar.DAY_OF_WEEK, resets);
if (hour == updateHour) {
resets.add(Calendar.HOUR_OF_DAY);
doNext(calendar, dot);
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
int updateDayOfMonth = findNextDay(calendar, this.daysOfMonth, dayOfMonth, daysOfWeek, dayOfWeek, resets);
if (dayOfMonth == updateDayOfMonth) {
resets.add(Calendar.DAY_OF_MONTH);
doNext(calendar, dot);
int month = calendar.get(Calendar.MONTH);
int updateMonth = findNext(this.months, month, calendar, Calendar.MONTH, Calendar.YEAR, resets);
if (month != updateMonth) {
if (calendar.get(Calendar.YEAR) - dot & 4) {
throw new IllegalArgumentException("Invalid cron expression \"" + this.expression +
"\" led to runaway search for next trigger");
doNext(calendar, dot);
private int findNext(BitSet bits, int value, Calendar calendar, int field, int nextField, List&Integer& lowerOrders) {　　　　　// 拿到下一个执行调度的秒数如当前时间的秒数是23任务是每10秒调度则拿到30，如果是58则返回-1
int nextValue = bits.nextSetBit(value);
if (nextValue == -1) {　　　　　　　 // 加一分（时，日）
calendar.add(nextField, 1);　　　　　　　 // 重置秒（分、时）
reset(calendar, Arrays.asList(field));
nextValue = bits.nextSetBit(0);
if (nextValue != value) {　　　　　　　 // 为日历设置下一个执行调度的秒（分、时）数
calendar.set(field, nextValue);
reset(calendar, lowerOrders);
return nextV
阅读(...) 评论()