學會這10種定時任務，有點飄了...

時間 2021-05-24

標籤 html java mysql linux git github web spring sql shell 欄目 HTML 简体版

原文原文鏈接

前言

最近有幾個讀者私信給我，問我他們的業務場景，要用什麼樣的定時任務。確實，在不用的業務場景下要用不一樣的定時任務，其實咱們的選擇仍是挺多的。我今天給你們總結10種很是實用的定時任務，總有一種是適合你的。html

一. linux自帶的定時任務

crontab

不知道你有沒有遇到過這種場景：有時須要臨時統計線上的數據，而後導出到excel表格中。這種需求有時較爲複雜，光靠寫sql語句是沒法知足需求的，這就須要寫java代碼了。而後將該程序打成一個jar包，在線上環境執行，最後將生成的excel文件下載到本地。java

爲了減少對線上環境的影響，咱們通常會選擇在凌晨1-2點，趁用戶量少的時候，執行統計程序。（其實凌晨4點左右，用戶纔是最少的）mysql

因爲時間太晚了，咱們徹底不必守在那裏等執行結果，一個定時任務就能能夠搞定。linux

那麼，這種狀況用哪一種定時任務更合適呢？git

答案是：linux系統的crontab。（不過也不排除有些項目沒部署在linux系統中）github

運行crontab -e，能夠編輯定時器，而後加入以下命令：web

`0 2 * * * /usr/local/java/jdk1.8/bin/java -jar /data/app/tool.jar > /logs/tool.log &`

就能夠在天天凌晨2點，定時執行tool.jar程序，而且把日誌輸出到tool.log文件中。固然你也能夠把後面的執行java程序的命令寫成shell腳本，更方便維護。spring

使用這種定時任務支持方便修改定時規則，有界面能夠統一管理配置的各類定時腳本。sql

crontab命令的基本格式以下：shell

`crontab [參數] [文件名]`

若是沒有指定文件名，則接收鍵盤上輸入的命令，並將它載入到crontab。

參數功能對照表以下：

參數

功能

-u

指定用戶

-e

編輯某個用戶的crontab文件內容

-l

顯示某個用戶的crontab文件內容

-r

刪除某用戶的crontab文件

-i

刪除某用戶的crontab文件時需確認

以上參數，若是沒有使用-u指定用戶，則默認使用的當前用戶。

經過crontab -e命令編輯文件內容，具體語法以下：

`[分] [小時] [日期] [月] [星期] 具體任務`

其中：

分，表示多少分鐘，範圍：0-59
小時，表示多少小時，範圍：0-23
日期，表示具體在哪一天，範圍：1-31
月，表示多少月，範圍：1-12
星期，表示多少周，範圍：0-7，0和7都表明星期日

還有一些特殊字符，好比：

*表明如什麼時候間，好比：*1*** 表示天天凌晨1點執行。
/表明每隔多久執行一次，好比：*/5 **** 表示每隔5分鐘執行一次。
,表明支持多個，好比：10 7,9,12 *** 表示在天天的七、九、12點10分各執行一次。
-表明支持一個範圍，好比：10 7-9 *** 表示在天天的七、八、9點10分各執行一次。

此外，順便說一下crontab須要crond服務支持，crond是linux下用來週期地執行某種任務的一個守護進程，在安裝linux操做系統後，默認會安裝crond服務工具，且crond服務默認就是自啓動的。crond進程每分鐘會按期檢查是否有要執行的任務，若是有，則會自動執行該任務。

能夠經過如下命令操做相關服務：

`service crond status // 查看運行狀態`
`service crond start //啓動服務`
`service crond stop //關閉服務`
`service crond restart //重啓服務`
`service crond reload //從新載入配置`

使用crontab的優缺點：

優勢：方便修改定時規則，支持一些較複雜的定時規則，經過文件能夠統一管理配好的各類定時腳本。
缺點：若是定時任務很是多，不太好找，並且必需要求操做系統是linux，不然沒法執行。

二. jdk自帶的定時任務

1.Thread

各位親愛的朋友，你沒看錯，Thread類真的能作定時任務。若是你看過一些定時任務框架的源碼，你最後會發現，它們的底層也會使用Thread類。

實現這種定時任務的具體代碼以下：

`public static void init() {`
 `new Thread(() -> {`
 `while (true) {`
 `try {`
 `System.out.println("doSameThing");`
 `Thread.sleep(1000 * 60 * 5);`
 `} catch (Exception e) {`
 `log.error(e);`
 `}`
 `}`
 `}).start();`
`}`

使用Thread類能夠作最簡單的定時任務，在run方法中有個while的死循環（固然還有其餘方式），執行咱們本身的任務。有個須要特別注意的地方是，須要用try...catch捕獲異常，不然若是出現異常，就直接退出循環，下次將沒法繼續執行了。

這種方式作的定時任務，只能週期性執行，不能支持定時在某個時間點執行。

此外，該線程能夠定義成守護線程，在後臺默默執行就好。

使用場景：好比項目中有時須要每隔10分鐘去下載某個文件，或者每隔5分鐘去讀取模板文件生成靜態html頁面等等，一些簡單的週期性任務場景。

使用Thread類的優缺點：

優勢：這種定時任務很是簡單，學習成本低，容易入手，對於那些簡單的週期性任務，是個不錯的選擇。
缺點：不支持指定某個時間點執行任務，不支持延遲執行等操做，功能過於單一，沒法應對一些較爲複雜的場景。

2.Timer

Timer類是jdk專門提供的定時器工具，用來在後臺線程計劃執行指定任務，在java.util包下，要跟TimerTask一塊兒配合使用。

Timer類實際上是一個任務調度器，它裏面包含了一個TimerThread線程，在這個線程中無限循環從TaskQueue中獲取TimerTask（該類實現了Runnable接口），調用其run方法，就能異步執行定時任務。咱們須要繼承TimerTask類，實現它的run方法，在該方法中加上本身的業務邏輯。

實現這種定時任務的具體代碼以下：

`public class TimerTest {`
 `public static void main(String[] args) {`
 `Timer timer = new Timer();`
 `timer.schedule(new TimerTask() {`
 `@Override`
 `public void run() {`
 `System.out.println("doSomething");`
 `}`
 `},2000,1000);`
 `}`
`}`

先實例化一個Timer類，而後調用它的schedule方法，在該方法中實例化TimerTask類，業務邏輯寫在run方法中。schedule方法最後的兩次參數分別表示：延遲時間 和 間隔時間，單位是毫秒。上面例子中，設置的定時任務是每隔1秒執行一次，延遲2秒執行。

主要包含6個方法：

schedule(TimerTask task, Date time), 指定任務task在指定時間time執行
schedule(TimerTask task, long delay), 指定任務task在指定延遲delay後執行
schedule(TimerTask task, Date firstTime,long period),指定任務task在指定時間firstTime執行後，進行重複固定延遲頻率peroid的執行
schedule(TimerTask task, long delay, long period), 指定任務task 在指定延遲delay 後，進行重複固定延遲頻率peroid的執行
scheduleAtFixedRate(TimerTask task,Date firstTime,long period), 指定任務task在指定時間firstTime執行後，進行重複固定延遲頻率peroid的執行
scheduleAtFixedRate(TimerTask task, long delay, long period), 指定任務task 在指定延遲delay 後，進行重複固定延遲頻率peroid的執行

不過使用Timer實現定時任務有如下問題：

因爲Timer是單線程執行任務，若是其中一個任務耗時很是長，會影響其餘任務的執行。
若是TimerTask拋出RuntimeException，Timer會中止全部任務的運行。

使用Timer類的優缺點：

優勢：很是方便實現多個週期性的定時任務，而且支持延遲執行，還支持在指定時間以後支持，功能還算強大。
缺點：若是其中一個任務耗時很是長，會影響其餘任務的執行。而且若是TimerTask拋出RuntimeException，Timer會中止全部任務的運行，因此阿里巴巴開發者規範中不建議使用它。

3.ScheduledExecutorService

ScheduledExecutorService是JDK1.5+版本引進的定時任務，該類位於java.util.concurrent併發包下。

ScheduledExecutorService是基於多線程的，設計的初衷是爲了解決Timer單線程執行，多個任務之間會互相影響的問題。

它主要包含4個方法：

schedule(Runnable command,long delay,TimeUnit unit)，帶延遲時間的調度，只執行一次，調度以後可經過Future.get()阻塞直至任務執行完畢。
schedule(Callable<V> callable,long delay,TimeUnit unit)，帶延遲時間的調度，只執行一次，調度以後可經過Future.get()阻塞直至任務執行完畢，而且能夠獲取執行結果。
scheduleAtFixedRate，表示以固定頻率執行的任務，若是當前任務耗時較多，超過定時週期period，則當前任務結束後會當即執行。
scheduleWithFixedDelay，表示以固定延時執行任務，延時是相對當前任務結束爲起點計算開始時間。

實現這種定時任務的具體代碼以下：

`public class ScheduleExecutorTest {`
 `public static void main(String[] args) {`
 `ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);`
 `scheduledExecutorService.scheduleAtFixedRate(() -> {`
 `System.out.println("doSomething");`
 `},1000,1000, TimeUnit.MILLISECONDS);`
 `}`
`}`

調用ScheduledExecutorService類的scheduleAtFixedRate方法實現週期性任務，每隔1秒鐘執行一次，每次延遲1秒再執行。

這種定時任務是阿里巴巴開發者規範中用來替代Timer類的方案，對於多線程執行週期性任務，是個不錯的選擇。

ScheduledExecutorService的優缺點：

優勢：基於多線程的定時任務，多個任務之間不會相關影響，支持週期性的執行任務，而且帶延遲功能。
缺點：不支持一些較複雜的定時規則。

三. spring支持的定時任務

1.spring task

spring task是spring3以上版本自帶的定時任務，實現定時任務的功能時，須要引入spring-context包，目前它支持：xml 和 註解 兩種方式。

1. 項目實戰

因爲xml方式太古老了，咱們以springboot項目中註解方式爲例。

第一步，在pom.xml文件中引入spring-context相關依賴。

`<dependency>`
 `<groupId>org.springframework</groupId>`
 `<artifactId>spring-context</artifactId>`
`</dependency>`

第二步，在springboot啓動類上加上@EnableScheduling註解。

`@EnableScheduling`
`@SpringBootApplication`
`public class Application {`
 `public static void main(String[] args) {`
 `new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);`
 `}`
`}`

第三步，使用@Scheduled註解定義定時規則。

`@Service`
`public class SpringTaskTest {`
 `@Scheduled(cron = "${sue.spring.task.cron}")`
 `public void fun() {`
 `System.out.println("doSomething");`
 `}`
`}`

第四步，在applicationContext.properties文件中配置參數：

`sue.spring.task.cron=*/10 * * * * ?`

這樣就能每隔10秒執行一次fun方法了。

2. cron規則

spring4以上的版本中，cron表達式包含6個參數：

`[秒] [分] [時] [日期] [月] [星期]`

還支持幾個經常使用的特殊符號：

*：表示任什麼時候間觸發任務
,：表示指定的時間觸發任務
-：表示一段時間內觸發任務
/：表示從哪個時刻開始，每隔多長時間觸發一次任務。
?：表示用於月中的天和週中的天兩個子表達式，表示不指定值。

cron表達式參數具體含義：

秒，取值範圍：0-59，支持*、,、-、/。
分，取值範圍：0-59，支持*、,、-、/。
時，取值範圍：0-23，支持*、,、-、/。
日期，取值範圍：1-31，支持*、,、-、/。比秒多了?，表示若是指定的星期觸發了，則配置的日期變成無效。
月，取值範圍：1-12，支持*、,、-、/。
星期，取值範圍：1~7，1表明星期天，6表明星期六，其餘的以此類推。支持*、,、-、/、?。比秒多了?，表示若是指定的日期觸發了，則配置的星期變成無效。

常見cron表達式使用舉例：

0 0 0 1 * ? 每個月1號零點執行
0 0 2 * * ? 天天凌晨2點執行
0 0 2 * * ? 天天凌晨2點執行
0 0/5 11 * * ? 天天11點-11點55分，每隔5分鐘執行一次
0 0 18 ? * WED 每週三下午6點執行

spring task先經過ScheduledAnnotationBeanPostProcessor類的processScheduled方法，解析和收集Scheduled註解中的參數，包含：cron表達式。

而後在ScheduledTaskRegistrar類的afterPropertiesSet方法中，默認初始化一個單線程的ThreadPoolExecutor執行任務。

對spring task感興趣的小夥伴，能夠加我微信找我私聊。

使用spring task的優缺點：

優勢：spring框架自帶的定時功能，springboot作了很是好的封裝，開啓和定義定時任務很是容易，支持複雜的cron表達式，能夠知足絕大多數單機版的業務場景。單個任務時，當前次的調度完成後，再執行下一次任務調度。
缺點：默認單線程，若是前面的任務執行時間太長，對後面任務的執行有影響。不支持集羣方式部署，不能作數據存儲型定時任務。

2.spring quartz

quartz是OpenSymphony開源組織在Job scheduling領域的開源項目，是由java開發的一個開源的任務日程管理系統。

quartz能作什麼？

做業調度：調用各類框架的做業腳本，例如shell,hive等。
定時任務：在某一預約的時刻，執行你想要執行的任務。

架構圖以下：

quartz包含的主要接口以下：

Scheduler 表明調度容器，一個調度容器中能夠註冊多個JobDetail和Trigger。
Job 表明工做，即要執行的具體內容。
JobDetail 表明具體的可執行的調度程序，Job是這個可執行程調度程序所要執行的內容。
JobBuilder 用於定義或構建JobDetail實例。
Trigger 表明調度觸發器，決定何時去調。
TriggerBuilder 用於定義或構建觸發器。
JobStore 用於存儲做業和任務調度期間的狀態。

1. 項目實戰

咱們仍是以springboot集成quartz爲例。

第一步，在pom.xml文件中引入quartz相關依賴。

`<dependency>`
 `<groupId>org.springframework.boot</groupId>`
 `<artifactId>spring-boot-starter-quartz</artifactId>`
`</dependency>`

第二步，建立真正的定時任務執行類，該類繼承QuartzJobBean。

`public class QuartzTestJob extends QuartzJobBean {`
 `@Override`
 `protected void executeInternal(JobExecutionContext context) throws JobExecutionException {`
 `String userName = (String) context.getJobDetail().getJobDataMap().get("userName");`
 `System.out.println("userName:" + userName);`
 `}`
`}`

第三步，建立調度程序JobDetail和調度器Trigger。

`@Configuration`
`public class QuartzConfig {`
 `@Value("${sue.spring.quartz.cron}")`
 `private String testCron;`
 `/**`
 `* 建立定時任務`
 `*/`
 `@Bean`
 `public JobDetail quartzTestDetail() {`
 `JobDetail jobDetail = JobBuilder.newJob(QuartzTestJob.class)`
 `.withIdentity("quartzTestDetail", "QUARTZ_TEST")`
 `.usingJobData("userName", "susan")`
 `.storeDurably()`
 `.build();`
 `return jobDetail;`
 `}`
 `/**`
 `* 建立觸發器`
 `*/`
 `@Bean`
 `public Trigger quartzTestJobTrigger() {`
 `//每隔5秒執行一次`
 `CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(testCron);`
 `//建立觸發器`
 `Trigger trigger = TriggerBuilder.newTrigger()`
 `.forJob(quartzTestDetail())`
 `.withIdentity("quartzTestJobTrigger", "QUARTZ_TEST_JOB_TRIGGER")`
 `.withSchedule(cronScheduleBuilder)`
 `.build();`
 `return trigger;`
 `}`
`}`

第四步，在applicationContext.properties文件中配置參數：

`sue.spring.quartz.cron=*/5 * * * * ?`

這樣就能每隔5秒執行一次QuartzTestJob類的executeInternal方法了。

CronTrigger配置格式:

`[秒] [分] [小時] [日] [月] [周] [年]`

spring quartz跟spring task的cron表達式規則基本一致，只是spring4以上的版本去掉了後面的年，而quartz的CronTrigger的年是非必填的，這裏我就不作過多介紹了。

使用spring quartz的優缺點：

優勢：默認是多線程異步執行，單個任務時，在上一個調度未完成時，下一個調度時間到時，會另起一個線程開始新的調度，多個任務之間互不影響。支持複雜的cron表達式，它能被集羣實例化，支持分佈式部署。
缺點：相對於spring task實現定時任務成本更高，須要手動配置QuartzJobBean、JobDetail和Trigger等。須要引入了第三方的quartz包，有必定的學習成本。不支持並行調度，不支持失敗處理策略和動態分片的策略等。

四. 分佈式定時任務

1.xxl-job

xxl-job是大衆點評（許雪裏）開發的一個分佈式任務調度平臺，其核心設計目標是開發迅速、學習簡單、輕量級、易擴展。現已開放源代碼並接入多家公司線上產品線，開箱即用。

xxl-job框架對quartz進行了擴展，使用mysql數據庫存儲數據，而且內置jetty做爲RPC服務調用。

主要特色以下：

有界面維護定時任務和觸發規則，很是容易管理。
能動態啓動或中止任務
支持彈性擴容縮容
支持任務失敗報警
支持動態分片
支持故障轉移
Rolling實時日誌
支持用戶和權限管理

管理界面：

總體架構圖以下：

使用quartz架構圖以下：

項目實戰

xxl-admin管理後臺部署和mysql腳本執行等這些前期準備工做，我就不過多介紹了，有需求的朋友能夠找我私聊，這些更偏向於運維的事情。

假設前期工做已經OK了，接下來咱們須要：

第一步，在pom.xml文件中引入xxl-job相關依賴。

`<dependency>`
 `<groupId>com.xuxueli</groupId>`
 `<artifactId>xxl-job-core</artifactId>`
`</dependency>`

第二步，在applicationContext.properties文件中配置參數：

`xxl.job.admin.address: http://localhost:8088/xxl-job-admin/`
`xxl.job.executor.appname: xxl-job-executor-sample`
`xxl.job.executor.port: 8888`
`xxl.job.executor.logpath: /data/applogs/xxl-job/`

第三步，建立HelloJobHandler類繼承IJobHandler類：

`@JobHandler(value = "helloJobHandler")`
`@Component`
`public class HelloJobHandler extends IJobHandler {`
 `@Override`
 `public ReturnT<String> execute(String param) {`
 `System.out.println("XXL-JOB, Hello World.");`
 `return SUCCESS;`
 `}`
`}`

這樣定時任務就配置好了。

建議把定時任務單獨部署到另一個服務中，跟api服務分開。根據我以往的經驗，job大部分狀況下，會對數據作批量操做，若是操做的數據量太大，可能會對服務的內存和cpu資源形成必定的影響。

使用xxl-job的優缺點：

優勢：有界面管理定時任務，支持彈性擴容縮容、動態分片、故障轉移、失敗報警等功能。它的功能很是強大，不少大廠在用，能夠知足絕大多數業務場景。
缺點：和quartz同樣，經過數據庫分佈式鎖，來控制任務不能重複執行。在任務很是多的狀況下，有一些性能問題。

2.elastic-job

elastic-job是噹噹網開發的彈性分佈式任務調度系統，功能豐富強大，採用zookeeper實現分佈式協調，實現任務高可用以及分片。它是專門爲高併發和複雜業務場景開發。

elastic-job目前是apache的shardingsphere項目下的一個子項目，官網地址：http://shardingsphere.apache....

elastic-job在2.x以後，出了兩個產品線：Elastic-Job-Lite和Elastic-Job-Cloud，而咱們通常使用Elastic-Job-Lite就可以知足需求。Elastic-Job-Lite定位爲輕量級無中心化解決方案，使用jar包的形式提供分佈式任務的協調服務，外部僅依賴於Zookeeper。。

主要特色以下：

分佈式調度協調
彈性擴容縮容
失效轉移
錯過執行做業重觸發
做業分片一致性，保證同一分片在分佈式環境中僅一個執行實例
自診斷並修復分佈式不穩定形成的問題
支持並行調度

總體架構圖：

項目實戰

第一步，在pom.xml文件中引入elastic-job相關依賴。

`<dependency>`
 `<groupId>com.dangdang</groupId>`
 `<artifactId>elastic-job-lite-core</artifactId>`
`</dependency>`
`<dependency>`
 `<groupId>com.dangdang</groupId>`
 `<artifactId>elastic-job-lite-spring</artifactId>`
`</dependency>`

第二步，增長ZKConfig類，配置zookeeper：

`@Configuration`
`@ConditionalOnExpression("'${zk.serverList}'.length() > 0")`
`public class ZKConfig {`
 `@Bean`
 `public ZookeeperRegistryCenter registry(@Value("${zk.serverList}") String serverList,`
 `@Value("${zk.namespace}") String namespace) {`
 `return new ZookeeperRegistryCenter(new ZookeeperConfiguration(serverList, namespace));`
 `}`
`}`

第三步，定義一個類實現SimpleJob接口：

`public class TestJob implements SimpleJob {`
 `@Override`
 `public void execute(ShardingContext shardingContext){`
 `System.out.println("ShardingTotalCount:"+shardingContext.getShardingTotalCount());`
 `System.out.println("ShardingItem:"+shardingContext.getShardingItem());`
 `}`
`}`

第四步，增長JobConfig配置任務：

`@Configuration`
`public class JobConfig {`
 `@Value("${sue.spring.elatisc.cron}")`
 `private String testCron;`
 `@Value("${sue.spring.elatisc.itemParameters}")`
 `private  String shardingItemParameters;`
 `@Value("${sue.spring.elatisc.jobParameters}")`
 `private String jobParameters =;`
 `@Value("${sue.spring.elatisc.shardingTotalCount}")`
 `private int shardingTotalCount;`
 
 `@Autowired`
 `private ZookeeperRegistryCenter registryCenter;`
 `@Bean`
 `public SimpleJob testJob() {`
 `return new TestJob();`
 `}`
 `@Bean`
 `public JobScheduler simpleJobScheduler(final SimpleJob simpleJob) {`
 `return new SpringJobScheduler(simpleJob, registryCenter, getConfiguration(simpleJob.getClass(),`
 `cron, shardingTotalCount, shardingItemParameters, jobParameters));`
 `}`
 `private geConfiguration getConfiguration(Class<? extends SimpleJob> jobClass,String cron,int shardingTotalCount,String shardingItemParameters,String jobParameters) {`
 `JobCoreConfiguration simpleCoreConfig = JobCoreConfiguration.newBuilder(jobClass.getName(), testCron, shardingTotalCount).`
 `shardingItemParameters(shardingItemParameters).jobParameter(jobParameters).build();`
 `SimpleJobConfiguration simpleJobConfig = new SimpleJobConfiguration(simpleCoreConfig, jobClass.getCanonicalName());`
 `LiteJobConfiguration jobConfig = LiteJobConfiguration.newBuilder(simpleJobConfig).overwrite(true).build();`
 `return jobConfig;`
 `}`
`}`

其中：

cron：cron表達式，定義觸發規則。
shardingTotalCount：定義做業分片總數
shardingItemParameters：定義分配項參數，通常用分片序列號和參數用等號分隔，多個鍵值對用逗號分隔，分片序列號從0開始，不可大於或等於做業分片總數。
jobParameters：做業自定義參數

第五步，在applicationContext.properties文件中配置參數：

`spring.application.name=elasticjobDemo`
`zk.serverList=localhost:2181`
`zk.namespace=elasticjobDemo`
`sue.spring.elatisc.cron=0/5 * * * * ?`
`sue.spring.elatisc.itemParameters=0=A,1=B,2=C,3=D`
`sue.spring.elatisc.jobParameters=test`
`sue.spring.elatisc.shardingTotalCount=4`

這樣定時任務就配置好了，建立定時任務的步驟，相對於xxl-job來講要繁瑣一些。

使用elastic-job的優缺點：