定时任务框架

最新推荐文章于 2024-02-26 11:06:04 发布
最新推荐文章于 2024-02-26 11:06:04 发布
阅读量95 收藏
点赞数
原文链接：http://www.cnblogs.com/Jeely/p/11224235.html
版权 
ScheduleIterator 接口 import java.util.Date;public interface ScheduleIterator {public Date next();// 获取下一个触发的时间点} Scheduler 类 import java.

定时任务框架代码。
整个框架就 3 个类：

ScheduleIterator.java
import java.util.Date;

public interface ScheduleIterator {
    Date next();
}
Scheduler.java
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Scheduler {
    class SchedulerTimerTask extends TimerTask {
        private SchedulerTask schedulerTask;
        private ScheduleIterator iterator;

        public SchedulerTimerTask(SchedulerTask schedulerTask, ScheduleIterator iterator) {
            this.schedulerTask = schedulerTask;
            this.iterator = iterator;
        }

        public void run() {
            schedulerTask.run();
            reschedule(schedulerTask, iterator);
        }
    }

    private final Timer timer = new Timer();

    public Scheduler() {
    }

    public void cancel() {
        timer.cancel();
    }

    public void schedule(SchedulerTask schedulerTask, ScheduleIterator iterator) {

        Date time = iterator.next();
        if (time == null) {
            schedulerTask.cancel();
        } else {
            synchronized (schedulerTask.lock) {
                if (schedulerTask.state != SchedulerTask.VIRGIN) {
                    throw new IllegalStateException("Task already scheduled or cancelled");
                }
                schedulerTask.state = SchedulerTask.SCHEDULED;
                schedulerTask.timerTask = new SchedulerTimerTask(schedulerTask, iterator);
                timer.schedule(schedulerTask.timerTask, time);
            }
        }
    }

    private void reschedule(SchedulerTask schedulerTask, ScheduleIterator iterator) {

        Date time = iterator.next();
        if (time == null) {
            schedulerTask.cancel();
        } else {
            synchronized (schedulerTask.lock) {
                if (schedulerTask.state != SchedulerTask.CANCELLED) {
                    schedulerTask.timerTask = new SchedulerTimerTask(schedulerTask, iterator);
                    timer.schedule(schedulerTask.timerTask, time);
                }
            }
        }
    }

}
SchedulerTask.java
import java.util.TimerTask;

public abstract class SchedulerTask implements Runnable {
    final Object lock = new Object();

    int state = VIRGIN;
    static final int VIRGIN = 0;
    static final int SCHEDULED = 1;
    static final int CANCELLED = 2;

    TimerTask timerTask;

    protected SchedulerTask() {
    }

    public abstract void run();

    public boolean cancel() {
        synchronized (lock) {
            if (timerTask != null) {
                timerTask.cancel();
            }
            boolean result = (state == SCHEDULED);
            state = CANCELLED;
            return result;
        }
    }

    public long scheduledExecutionTime() {
        synchronized (lock) {
            return timerTask == null ? 0 : timerTask.scheduledExecutionTime();
        }
    }

}
自己写的 ScheduleIterator 实现类 以及一个测试类

SimpleScheduleIterator.java
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import com.jeecms.common.task.scheduling.ScheduleIterator;

/**
 * 时间进度迭代器 <li>返回 月/周/天/小时/分钟/秒 计划的下一次执行时间</li> <li>约定：参数以逗号分隔,*号表示无值</li> <li>
 * 参数解释： <br>
 * 第一位：每个月的第几周</br> <br>
 * 第二位：每周的第几天</br> <br>
 * 第三位：天(几号)</br> <br>
 * 第四位：小时(24小时制)</br> <br>
 * 第五位：分钟</br> <br>
 * 第六位：秒</br></li> <li>参数样例： <br>
 * 1,6,4,15,20,30 表示 从今天的15:20:30开始，每隔一个月执行一次,即下次执行时间是 下个月的第一周的第6天的15:20:30</br>
 * <br>
 * *,6,4,15,20,30 表示 从今天的15:20:30开始，每隔一周执行一次,即下次执行时间是 下一周的第6天的15:20:30</br> <br>
 * *,*,4,15,20,30 表示 从今天的15:20:30开始，每隔一天执行一次,即下次执行时间是 下一天的15:20:30</br> <br>
 * *,*,*,15,20,30 表示 从今天的15:20:30开始，每隔一小时执行一次,即下次执行时间是 16:20:30</br> <br>
 * *,*,*,*,20,30 表示 从这个小时的20:30开始，每隔一分钟执行一次,即下次执行时间是 *:21:30</br> <br>
 * *,*,*,*,*,30 表示 从当前时间的30秒开始，每隔一秒执行一次,即下次执行时间是 *:*:31</br></li>
 * 
 * @author javacoo
 * @since 2011-11-03
 */
public class SimpleScheduleIterator implements ScheduleIterator {
    private final ScheduleParamBean scheduleParamBean;
    private final Calendar calendar = Calendar.getInstance();
    private final Calendar orginCalendar = Calendar.getInstance();

    public SimpleScheduleIterator(final ScheduleParamBean scheduleParamBean) {
        this(scheduleParamBean, new Date());
    }

    public SimpleScheduleIterator(final ScheduleParamBean scheduleParamBean, Date date) {
        this.scheduleParamBean = scheduleParamBean;

        orginCalendar.setTime(date);
        calendar.setTime(date);
        if (null != scheduleParamBean.getWeekOfMonth()) {
            calendar.set(Calendar.WEEK_OF_MONTH, scheduleParamBean.getWeekOfMonth());
        }
        // 如果设置了每周的第几天和一个月的第几天，则忽略一个月的第几天
        if (null != scheduleParamBean.getDayOfWeek()) {
            calendar.set(Calendar.DAY_OF_WEEK, scheduleParamBean.getDayOfWeek());
        } else if (null != scheduleParamBean.getDayOfMonth()) {
            calendar.set(Calendar.DAY_OF_MONTH, scheduleParamBean.getDayOfMonth());
        }
        if (null != scheduleParamBean.getHourOfDay()) {
            calendar.set(Calendar.HOUR_OF_DAY, scheduleParamBean.getHourOfDay());
        }
        if (null != scheduleParamBean.getMinute()) {
            calendar.set(Calendar.MINUTE, scheduleParamBean.getMinute());
        }
        if (null != scheduleParamBean.getSecond()) {
            calendar.set(Calendar.SECOND, scheduleParamBean.getSecond());
        }
        calendar.set(Calendar.MILLISECOND, 0);

        if (!calendar.getTime().before(date)) {
            System.out.println(calendar.getTime() + "大于当前时间：" + date);
            if (null != scheduleParamBean.getWeekOfMonth()) {
                calendar.add(Calendar.MONTH, -1);
            } else if (null != scheduleParamBean.getDayOfWeek()) {
                calendar.add(Calendar.DAY_OF_WEEK, -6);
            } else if (null != scheduleParamBean.getDayOfMonth()) {
                calendar.add(Calendar.DAY_OF_MONTH, -1);
            } else if (null != scheduleParamBean.getHourOfDay()) {
                calendar.add(Calendar.HOUR_OF_DAY, -1);
            } else if (null != scheduleParamBean.getMinute()) {
                calendar.add(Calendar.MINUTE, -1);
            } else if (null != scheduleParamBean.getSecond()) {
                calendar.add(Calendar.SECOND, -1);
            }
        } else {
            System.out.println(calendar.getTime() + "小于当前时间：" + date);
            if (null != scheduleParamBean.getDayOfMonth()) {
                calendar.add(Calendar.DAY_OF_MONTH, orginCalendar.get(Calendar.DAY_OF_MONTH) - scheduleParamBean.getDayOfMonth());
            } else if (null != scheduleParamBean.getHourOfDay()) {
                calendar.add(Calendar.HOUR_OF_DAY, orginCalendar.get(Calendar.HOUR_OF_DAY) - scheduleParamBean.getHourOfDay());
            } else if (null != scheduleParamBean.getMinute()) {
                calendar.add(Calendar.MINUTE, orginCalendar.get(Calendar.MINUTE) - scheduleParamBean.getMinute());
            } else if (null != scheduleParamBean.getSecond()) {
                calendar.add(Calendar.SECOND, orginCalendar.get(Calendar.SECOND) - scheduleParamBean.getSecond());
            }
        }
    }

    public Date next() {
        if (null != scheduleParamBean.getWeekOfMonth()) {
            calendar.add(Calendar.MONTH, 1);
        } else if (null != scheduleParamBean.getDayOfWeek()) {
            calendar.add(Calendar.DAY_OF_WEEK, 6);
        } else if (null != scheduleParamBean.getDayOfMonth()) {
            calendar.add(Calendar.DAY_OF_MONTH, 1);
        } else if (null != scheduleParamBean.getHourOfDay()) {
            calendar.add(Calendar.HOUR_OF_DAY, 1);
        } else if (null != scheduleParamBean.getMinute()) {
            calendar.add(Calendar.MINUTE, 1);
        } else if (null != scheduleParamBean.getSecond()) {
            calendar.add(Calendar.SECOND, 1);
        }
        System.out.println("下次执行时间:" + calendar.getTime());
        return calendar.getTime();
    }

}
ScheduleParamBean.java
/**
 * 时间计划参数bean
 * 
 * @author javacoo
 * @since 2011-11-04
 */
public class ScheduleParamBean {
    /** 每个月的第几周,每周的第几天,每个月的第几天,小时(24小时制),分钟,秒 */
    private Integer weekOfMonth, dayOfWeek, dayOfMonth, hourOfDay, minute, second;

    public ScheduleParamBean() {

    }

    public ScheduleParamBean(Integer weekOfMonth, Integer dayOfWeek, Integer dayOfMonth, Integer hourOfDay, Integer minute, Integer second) {
        super();
        this.weekOfMonth = weekOfMonth;
        this.dayOfWeek = dayOfWeek;
        this.dayOfMonth = dayOfMonth;
        this.hourOfDay = hourOfDay;
        this.minute = minute;
        this.second = second;
    }

    public Integer getWeekOfMonth() {
        return weekOfMonth;
    }

    public void setWeekOfMonth(Integer weekOfMonth) {
        this.weekOfMonth = weekOfMonth;
    }

    public Integer getDayOfWeek() {
        return dayOfWeek;
    }

    public void setDayOfWeek(Integer dayOfWeek) {
        this.dayOfWeek = dayOfWeek;
    }

    public Integer getDayOfMonth() {
        return dayOfMonth;
    }

    public void setDayOfMonth(Integer dayOfMonth) {
        this.dayOfMonth = dayOfMonth;
    }

    public Integer getHourOfDay() {
        return hourOfDay;
    }

    public void setHourOfDay(Integer hourOfDay) {
        this.hourOfDay = hourOfDay;
    }

    public Integer getMinute() {
        return minute;
    }

    public void setMinute(Integer minute) {
        this.minute = minute;
    }

    public Integer getSecond() {
        return second;
    }

    public void setSecond(Integer second) {
        this.second = second;
    }

    @Override
    public String toString() {
        return "ScheduleParamBean [dayOfMonth=" + dayOfMonth + ", dayOfWeek=" + dayOfWeek + ", hourOfDay=" + hourOfDay + ", minute=" + minute
                + ", second=" + second + ", weekOfMonth=" + weekOfMonth + "]";
    }

}
TestSchedule.java
/**
 * 测试
 * 
 * @author javacoo
 * @since 2011-11-03
 */
public class TestSchedule {
    private final Scheduler scheduler = new Scheduler();

    private final ScheduleParamBean scheduleParamBean;

    public TestSchedule(final ScheduleParamBean scheduleParamBean) {
        this.scheduleParamBean = scheduleParamBean;
    }

    public void start() {
        scheduler.schedule(new SchedulerTask() {
            public void run() {
                execute();
            }

            private void execute() {
                System.out.println("任务执行");
            }
        }, new SimpleScheduleIterator(scheduleParamBean));
    }

    public static void main(String[] args) {

        ScheduleParamBean scheduleParamBean = new ScheduleParamBean();
        scheduleParamBean.setWeekOfMonth(1);
        scheduleParamBean.setDayOfWeek(6);
        scheduleParamBean.setDayOfMonth(4);
        scheduleParamBean.setHourOfDay(16);
        scheduleParamBean.setMinute(22);
        scheduleParamBean.setSecond(0);
        TestSchedule test = new TestSchedule(scheduleParamBean);
        test.start();

    }

}
以下是整合到 JEECMS 采集器多线程版的代码片段

/** 
 * 开始执行采集任务 
 */ 
public boolean start(Integer id) { 
CmsAcquisition acqu = cmsAcquisitionMng.findById(id); 
if (acqu == null || acqu.getStatus() == CmsAcquisition.START) { 
return false; 
} 
TaskSchedulerManage taskManage = new TaskSchedulerManage(this,acqu); 
taskManage.start(); 
return true; 
} 


private class TaskSchedulerManage { 
private final Scheduler scheduler = new Scheduler(); 
private final MultiThreadAcquisitionSvcImpl multiThreadAcquisitionSvc; 
private final CmsAcquisition acqu; 
public TaskSchedulerManage(MultiThreadAcquisitionSvcImpl multiThreadAcquisitionSvc,CmsAcquisition acqu) { 
this.multiThreadAcquisitionSvc = multiThreadAcquisitionSvc; 
this.acqu = acqu; 
} 
public void start() { 
scheduler.schedule(new SchedulerTask() { 
public void run() { 
processer(); 
} 
private void processer() { 
System.out.println("============开始执行计划任务================="); 
new Thread(new MainThreadProcesser(multiThreadAcquisitionSvc,acqu)).start(); 
} 
}, new SimpleScheduleIterator(new ScheduleParamBean(1,6,4,17,24,30))); 
} 
}
注：关键是 ScheduleIterator 实现类了，框架有多强大 完全取决于你的 ScheduleIterator 实现类了。

 

ScheduleIterator 接口 import java.util.Date;public interface ScheduleIterator {public Date next();// 获取下一个触发的时间点} Scheduler 类 import java.

定时任务框架代码。
整个框架就 3 个类：

  • ScheduleIterator.java
1
2
3
4
5
 
import java.util.Date;

public interface ScheduleIterator {
	Date next();
}
  • Scheduler.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Scheduler {
	class SchedulerTimerTask extends TimerTask {
		private SchedulerTask schedulerTask;
		private ScheduleIterator iterator;

		public SchedulerTimerTask(SchedulerTask schedulerTask, ScheduleIterator iterator) {
			this.schedulerTask = schedulerTask;
			this.iterator = iterator;
		}

		public void run() {
			schedulerTask.run();
			reschedule(schedulerTask, iterator);
		}
	}

	private final Timer timer = new Timer();

	public Scheduler() {
	}

	public void cancel() {
		timer.cancel();
	}

	public void schedule(SchedulerTask schedulerTask, ScheduleIterator iterator) {

		Date time = iterator.next();
		if (time == null) {
			schedulerTask.cancel();
		} else {
			synchronized (schedulerTask.lock) {
				if (schedulerTask.state != SchedulerTask.VIRGIN) {
					throw new IllegalStateException("Task already scheduled or cancelled");
				}
				schedulerTask.state = SchedulerTask.SCHEDULED;
				schedulerTask.timerTask = new SchedulerTimerTask(schedulerTask, iterator);
				timer.schedule(schedulerTask.timerTask, time);
			}
		}
	}

	private void reschedule(SchedulerTask schedulerTask, ScheduleIterator iterator) {

		Date time = iterator.next();
		if (time == null) {
			schedulerTask.cancel();
		} else {
			synchronized (schedulerTask.lock) {
				if (schedulerTask.state != SchedulerTask.CANCELLED) {
					schedulerTask.timerTask = new SchedulerTimerTask(schedulerTask, iterator);
					timer.schedule(schedulerTask.timerTask, time);
				}
			}
		}
	}

}
  • SchedulerTask.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
import java.util.TimerTask;

public abstract class SchedulerTask implements Runnable {
	final Object lock = new Object();

	int state = VIRGIN;
	static final int VIRGIN = 0;
	static final int SCHEDULED = 1;
	static final int CANCELLED = 2;

	TimerTask timerTask;

	protected SchedulerTask() {
	}

	public abstract void run();

	public boolean cancel() {
		synchronized (lock) {
			if (timerTask != null) {
				timerTask.cancel();
			}
			boolean result = (state == SCHEDULED);
			state = CANCELLED;
			return result;
		}
	}

	public long scheduledExecutionTime() {
		synchronized (lock) {
			return timerTask == null ? 0 : timerTask.scheduledExecutionTime();
		}
	}

}

自己写的 ScheduleIterator 实现类 以及一个测试类

  • SimpleScheduleIterator.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import com.jeecms.common.task.scheduling.ScheduleIterator;

/**
 * 时间进度迭代器 <li>返回 月/周/天/小时/分钟/秒 计划的下一次执行时间</li> <li>约定：参数以逗号分隔,*号表示无值</li> <li>
 * 参数解释： <br>
 * 第一位：每个月的第几周</br> <br>
 * 第二位：每周的第几天</br> <br>
 * 第三位：天(几号)</br> <br>
 * 第四位：小时(24小时制)</br> <br>
 * 第五位：分钟</br> <br>
 * 第六位：秒</br></li> <li>参数样例： <br>
 * 1,6,4,15,20,30 表示 从今天的15:20:30开始，每隔一个月执行一次,即下次执行时间是 下个月的第一周的第6天的15:20:30</br>
 * <br>
 * *,6,4,15,20,30 表示 从今天的15:20:30开始，每隔一周执行一次,即下次执行时间是 下一周的第6天的15:20:30</br> <br>
 * *,*,4,15,20,30 表示 从今天的15:20:30开始，每隔一天执行一次,即下次执行时间是 下一天的15:20:30</br> <br>
 * *,*,*,15,20,30 表示 从今天的15:20:30开始，每隔一小时执行一次,即下次执行时间是 16:20:30</br> <br>
 * *,*,*,*,20,30 表示 从这个小时的20:30开始，每隔一分钟执行一次,即下次执行时间是 *:21:30</br> <br>
 * *,*,*,*,*,30 表示 从当前时间的30秒开始，每隔一秒执行一次,即下次执行时间是 *:*:31</br></li>
 * 
 * @author javacoo
 * @since 2011-11-03
 */
public class SimpleScheduleIterator implements ScheduleIterator {
	private final ScheduleParamBean scheduleParamBean;
	private final Calendar calendar = Calendar.getInstance();
	private final Calendar orginCalendar = Calendar.getInstance();

	public SimpleScheduleIterator(final ScheduleParamBean scheduleParamBean) {
		this(scheduleParamBean, new Date());
	}

	public SimpleScheduleIterator(final ScheduleParamBean scheduleParamBean, Date date) {
		this.scheduleParamBean = scheduleParamBean;

		orginCalendar.setTime(date);
		calendar.setTime(date);
		if (null != scheduleParamBean.getWeekOfMonth()) {
			calendar.set(Calendar.WEEK_OF_MONTH, scheduleParamBean.getWeekOfMonth());
		}
		// 如果设置了每周的第几天和一个月的第几天，则忽略一个月的第几天
		if (null != scheduleParamBean.getDayOfWeek()) {
			calendar.set(Calendar.DAY_OF_WEEK, scheduleParamBean.getDayOfWeek());
		} else if (null != scheduleParamBean.getDayOfMonth()) {
			calendar.set(Calendar.DAY_OF_MONTH, scheduleParamBean.getDayOfMonth());
		}
		if (null != scheduleParamBean.getHourOfDay()) {
			calendar.set(Calendar.HOUR_OF_DAY, scheduleParamBean.getHourOfDay());
		}
		if (null != scheduleParamBean.getMinute()) {
			calendar.set(Calendar.MINUTE, scheduleParamBean.getMinute());
		}
		if (null != scheduleParamBean.getSecond()) {
			calendar.set(Calendar.SECOND, scheduleParamBean.getSecond());
		}
		calendar.set(Calendar.MILLISECOND, 0);

		if (!calendar.getTime().before(date)) {
			System.out.println(calendar.getTime() + "大于当前时间：" + date);
			if (null != scheduleParamBean.getWeekOfMonth()) {
				calendar.add(Calendar.MONTH, -1);
			} else if (null != scheduleParamBean.getDayOfWeek()) {
				calendar.add(Calendar.DAY_OF_WEEK, -6);
			} else if (null != scheduleParamBean.getDayOfMonth()) {
				calendar.add(Calendar.DAY_OF_MONTH, -1);
			} else if (null != scheduleParamBean.getHourOfDay()) {
				calendar.add(Calendar.HOUR_OF_DAY, -1);
			} else if (null != scheduleParamBean.getMinute()) {
				calendar.add(Calendar.MINUTE, -1);
			} else if (null != scheduleParamBean.getSecond()) {
				calendar.add(Calendar.SECOND, -1);
			}
		} else {
			System.out.println(calendar.getTime() + "小于当前时间：" + date);
			if (null != scheduleParamBean.getDayOfMonth()) {
				calendar.add(Calendar.DAY_OF_MONTH, orginCalendar.get(Calendar.DAY_OF_MONTH) - scheduleParamBean.getDayOfMonth());
			} else if (null != scheduleParamBean.getHourOfDay()) {
				calendar.add(Calendar.HOUR_OF_DAY, orginCalendar.get(Calendar.HOUR_OF_DAY) - scheduleParamBean.getHourOfDay());
			} else if (null != scheduleParamBean.getMinute()) {
				calendar.add(Calendar.MINUTE, orginCalendar.get(Calendar.MINUTE) - scheduleParamBean.getMinute());
			} else if (null != scheduleParamBean.getSecond()) {
				calendar.add(Calendar.SECOND, orginCalendar.get(Calendar.SECOND) - scheduleParamBean.getSecond());
			}
		}
	}

	public Date next() {
		if (null != scheduleParamBean.getWeekOfMonth()) {
			calendar.add(Calendar.MONTH, 1);
		} else if (null != scheduleParamBean.getDayOfWeek()) {
			calendar.add(Calendar.DAY_OF_WEEK, 6);
		} else if (null != scheduleParamBean.getDayOfMonth()) {
			calendar.add(Calendar.DAY_OF_MONTH, 1);
		} else if (null != scheduleParamBean.getHourOfDay()) {
			calendar.add(Calendar.HOUR_OF_DAY, 1);
		} else if (null != scheduleParamBean.getMinute()) {
			calendar.add(Calendar.MINUTE, 1);
		} else if (null != scheduleParamBean.getSecond()) {
			calendar.add(Calendar.SECOND, 1);
		}
		System.out.println("下次执行时间:" + calendar.getTime());
		return calendar.getTime();
	}

}
  • ScheduleParamBean.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
/**
 * 时间计划参数bean
 * 
 * @author javacoo
 * @since 2011-11-04
 */
public class ScheduleParamBean {
	/** 每个月的第几周,每周的第几天,每个月的第几天,小时(24小时制),分钟,秒 */
	private Integer weekOfMonth, dayOfWeek, dayOfMonth, hourOfDay, minute, second;

	public ScheduleParamBean() {

	}

	public ScheduleParamBean(Integer weekOfMonth, Integer dayOfWeek, Integer dayOfMonth, Integer hourOfDay, Integer minute, Integer second) {
		super();
		this.weekOfMonth = weekOfMonth;
		this.dayOfWeek = dayOfWeek;
		this.dayOfMonth = dayOfMonth;
		this.hourOfDay = hourOfDay;
		this.minute = minute;
		this.second = second;
	}

	public Integer getWeekOfMonth() {
		return weekOfMonth;
	}

	public void setWeekOfMonth(Integer weekOfMonth) {
		this.weekOfMonth = weekOfMonth;
	}

	public Integer getDayOfWeek() {
		return dayOfWeek;
	}

	public void setDayOfWeek(Integer dayOfWeek) {
		this.dayOfWeek = dayOfWeek;
	}

	public Integer getDayOfMonth() {
		return dayOfMonth;
	}

	public void setDayOfMonth(Integer dayOfMonth) {
		this.dayOfMonth = dayOfMonth;
	}

	public Integer getHourOfDay() {
		return hourOfDay;
	}

	public void setHourOfDay(Integer hourOfDay) {
		this.hourOfDay = hourOfDay;
	}

	public Integer getMinute() {
		return minute;
	}

	public void setMinute(Integer minute) {
		this.minute = minute;
	}

	public Integer getSecond() {
		return second;
	}

	public void setSecond(Integer second) {
		this.second = second;
	}

	@Override
	public String toString() {
		return "ScheduleParamBean [dayOfMonth=" + dayOfMonth + ", dayOfWeek=" + dayOfWeek + ", hourOfDay=" + hourOfDay + ", minute=" + minute
				+ ", second=" + second + ", weekOfMonth=" + weekOfMonth + "]";
	}

}
  • TestSchedule.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
/**
 * 测试
 * 
 * @author javacoo
 * @since 2011-11-03
 */
public class TestSchedule {
	private final Scheduler scheduler = new Scheduler();

	private final ScheduleParamBean scheduleParamBean;

	public TestSchedule(final ScheduleParamBean scheduleParamBean) {
		this.scheduleParamBean = scheduleParamBean;
	}

	public void start() {
		scheduler.schedule(new SchedulerTask() {
			public void run() {
				execute();
			}

			private void execute() {
				System.out.println("任务执行");
			}
		}, new SimpleScheduleIterator(scheduleParamBean));
	}

	public static void main(String[] args) {

		ScheduleParamBean scheduleParamBean = new ScheduleParamBean();
		scheduleParamBean.setWeekOfMonth(1);
		scheduleParamBean.setDayOfWeek(6);
		scheduleParamBean.setDayOfMonth(4);
		scheduleParamBean.setHourOfDay(16);
		scheduleParamBean.setMinute(22);
		scheduleParamBean.setSecond(0);
		TestSchedule test = new TestSchedule(scheduleParamBean);
		test.start();

	}

}

以下是整合到 JEECMS 采集器多线程版的代码片段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
/** 
 * 开始执行采集任务 
 */ 
public boolean start(Integer id) { 
CmsAcquisition acqu = cmsAcquisitionMng.findById(id); 
if (acqu == null || acqu.getStatus() == CmsAcquisition.START) { 
return false; 
} 
TaskSchedulerManage taskManage = new TaskSchedulerManage(this,acqu); 
taskManage.start(); 
return true; 
} 


private class TaskSchedulerManage { 
private final Scheduler scheduler = new Scheduler(); 
private final MultiThreadAcquisitionSvcImpl multiThreadAcquisitionSvc; 
private final CmsAcquisition acqu; 
public TaskSchedulerManage(MultiThreadAcquisitionSvcImpl multiThreadAcquisitionSvc,CmsAcquisition acqu) { 
this.multiThreadAcquisitionSvc = multiThreadAcquisitionSvc; 
this.acqu = acqu; 
} 
public void start() { 
scheduler.schedule(new SchedulerTask() { 
public void run() { 
processer(); 
} 
private void processer() { 
System.out.println("============开始执行计划任务================="); 
new Thread(new MainThreadProcesser(multiThreadAcquisitionSvc,acqu)).start(); 
} 
}, new SimpleScheduleIterator(new ScheduleParamBean(1,6,4,17,24,30))); 
} 
}

注：关键是 ScheduleIterator 实现类了，框架有多强大 完全取决于你的 ScheduleIterator 实现类了。

转载于:https://www.cnblogs.com/Jeely/p/11224235.html

weixin_30859423
关注
Quartz定时任务框架
12-17
总之，Quartz定时任务框架为Java开发者提供了一套灵活且功能强大的任务调度解决方案。通过理解其核心组件和API，我们可以方便地创建和管理各种定时任务，以满足各种业务需求。在这个简单的示例中，我们看到了如何每...
聊聊常见的定时任务调度框架
G探险者的博客
02-21 2135
在许多应用中，需要定期执行一些任务，例如生成报告、备份数据、更新缓存等等。这些任务通常需要在规定的时间间隔内自动执行，并且需要稳定、可靠地运行，且应该能够有效地管理和监控这些任务的执行情况。 于是就诞生了任务调度框架。 使用任务调度框架可以帮助我们将任务的执行时间和频率以及任务的执行结果都管理起来。任务调度框架通常提供了灵活的配置选项，可以方便地指定任务的执行计划，并支持各种类型的任务，例如调用一个方法、执行一个 shell 脚本、发送一封电子邮件等等。同时，任务调度框架还提供了任务的执行日志、执行历史和错
关于常见的定时任务（Spring Task框架，Quartz框架，XXL-job框架）
library_yb的博客
06-13 1750
这个是spring自身的定时任务，也是最简单的定时任务，只需要掌握Cron表达式即可(不会不用着急，网上一找一大把)使用Spring Task框架步骤@Scheduled(fixedRate = 5000) 第一步：加入注解，这个是每5秒执行一次// 执行定时任务的代码第二步：在人口类加入@EnableScheduling注解就完成了。
定时任务特辑 | Quartz、xxl-job、elastic-job、Cron四个定时任务框架对比，和Spring Boot集成实战
Web3 & Basketball
12-02 7061
QuartzQuartz 是一款基于 Java 的开源调度框架，可以用于在指定时间执行任务或在指定时间间隔内重复执行任务。它提供了丰富的 API 和灵活的配置选项，可以满足各种不同的调度需求。Quartz 支持集群部署，可以实现任务的分布式调度。优点：强大的调度功能，支持集群部署，提供丰富的 API 和灵活的配置选项。缺点：学习曲线较陡峭，配置相对复杂，没有自带的管理界面，调度逻辑和执行任务耦合在一起。
Java中三种定时任务总结（schedule，quartz，xxl-job）
林隐的博客
12-04 6335
Java中三种定时任务总结（schedule，quartz，xxl-job）
定时任务框架Quartz Demo
01-12
Quartz是一款开源的Java定时任务框架，用于在Java应用程序中创建和管理定时任务。它提供了丰富的API和功能，使得开发者可以灵活地定义和调度任务，实现应用中的周期性任务执行。在"定时任务框架Quartz Demo"项目中，...
轻量级定时任务框架.zip
07-19
Java轻量级定时任务框架是开发中不可或缺的一部分，它允许开发者在特定的时间点执行特定的任务，无需编写大量的调度代码。本框架以ZIP压缩包的形式提供，名为"轻量级定时任务框架.zip"，其中包含的核心组件是Quartz...
定时任务框架学习资料上篇
02-21
【定时任务框架学习资料上篇】是一份针对定时任务处理技术的深度学习资源，主要聚焦在ElasticJob这一流行的分布式定时任务框架上。ElasticJob是阿里开源的一个强大的分布式任务调度解决方案，它提供了两种类型的定时...
几种常用定时任务框架的介绍及比较
Brave_heart4pzj的博客
08-11 625
https://www.cnblogs.com/hbbbs/articles/11416103.html https://www.jianshu.com/p/d160f2536de7 动态定时任务的实现案例
定时任务框架有哪些？xxl-job你了解多少？
最新发布
meser88的博客
02-26 164
从上图可以看出，
定时任务框架总结
S_L__的博客
01-09 680
定时任务框架总结
【2.1 分布式定时任务（XXL-JOB）】一文汇总所有常见的Java定时任务框架介绍
本本本添哥
04-17 1426
在Java中，常见的定时任务框架包括Quartz、Spring Task、Elastic-Job和XXL-JOB等。
五种定时任务方案(Timer+ScheduleExecutorService+spring task+多线程执行+quartz)
usa_washington的博客
09-07 3903
定时任务方案
Spring Boot定时任务
Joker_ZJN的博客
05-31 3581
结合实际业务场景，详解spring boot定时任务。
定时任务框架快速入门
白豆五的博客
04-18 1216
初识Spring Task、Quartz、XXL-JOB定时任务框架
Java定时任务及常见框架
weixin_45734473的博客
10-08 2563
Java定时任务及常见框架
3个.NET开源简单易用的任务调度框架
专注于C#/.NET/.NET Core学习、工作、面试干货和实战教程分享。这里聚焦了大量的C#/.NET/.NET Core优质文章、开源项目、实用工具和学习、工作、面试心得。
01-03 1386
今天分享3个.NET开源、简单、易用的任务调度框架，帮助大家在做定时任务调度框架技术选型的时候有一个参考。
PHP定时任务框架案例源码解析
1. 定时任务框架的基本概念和原理：定时任务框架通常是用来在指定时间执行特定操作的工具。它们可以用来自动化执行周期性的任务，比如数据备份、发送定时邮件、进行网站内容更新等。框架的工作原理一般是通过调度器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值