定时任务框架APScheduler

最新推荐文章于 2024-01-25 17:45:31 发布

Max-Jin

最新推荐文章于 2024-01-25 17:45:31 发布

阅读量272

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/weixin_43843657/article/details/119419612

版权

python 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

前言

工作中遇到了有些任务需要定时执行的需求，Python中定时任务的解决方案，总体来说有四种，分别是： crontab、 scheduler、 Celery、 APScheduler，其中 crontab不适合多台服务器的配置、 scheduler太过于简单、 Celery依赖的软件比较多，比较耗资源。最好的解决方案就是 APScheduler。

APScheduler使用起来十分方便。提供了基于日期、固定时间间隔以及 crontab类型的任务。还可以在程序运行过程中动态的新增任务和删除任务。在任务运行过程中，还可以把任务存储起来，下次启动运行依然保留之前的状态。另外最重要的一个特点是，因为他是基于 Python语言的库，所以是可以跨平台的，一段代码，处处运行！

四个基本对象

触发器（triggers）：
触发器就是根据你指定的触发方式，比如是按照时间间隔，还是按照 crontab触发，触发条件是什么等。每个任务都有自己的触发器。
任务存储器（job stores）：
任务存储器是可以存储任务的地方，默认情况下任务保存在内存，也可将任务保存在各种数据库中。任务存储进去后，会进行序列化，然后也可以反序列化提取出来，继续执行。
执行器（executors）：
执行器的目的是安排任务到线程池或者进程池中运行的。
调度器（schedulers）：
任务调度器是属于整个调度的总指挥官。他会合理安排作业存储器、执行器、触发器进行工作，并进行添加和删除任务等。调度器通常是只有一个的。开发人员很少直接操作触发器、存储器、执行器等。因为这些都由调度器自动来实现了。

触发器

触发器有两种，第一种是 interval，第二种是 crontab。 interval可以具体指定多少时间间隔执行一次。 crontab可以指定执行的日期策略。

date触发器：
在某个日期时间只触发一次事件。示例代码如下：

from datetime import date
from apscheduler . schedulers . blocking import BlockingScheduler

sched = BlockingScheduler

def my_job ( text ):
	print ( text )
	sched.add_job ( my_job , 'date' , run_date = date ( 2020 , 5 , 22 ), args =[ 'text' ])
	sched.start

interval触发器：
想要在固定的时间间隔触发事件。 interval的触发器可以设置以下的触发参数：

weeks ：周。整型。
days ：一个月中的第几天。整型。
hours ：小时。整型。
minutes ：分钟。整型。
seconds ：秒。整型。
start_date ：间隔触发的起始时间。
end_date ：间隔触发的结束时间。
jitter ：触发的时间误差。

def cron_task :
	scheduler = BlockingScheduler
	scheduler.add_job ( tick , "cron" , hour = 11 , minute = 24 )
	scheduler.start

crontab触发器：
在某个确切的时间周期性的触发事件。可以使用的参数如下：

year ：4位数字的年份。
month ：1-12月份。
day ：1-31日。
week ：1-53周。
day_of_week ：一个礼拜中的第几天（ 0 - 6 或者 mon 、 tue 、 wed 、 thu 、 fri 、 sat 、 sun ）。
hour ： 0 - 23 小时。
minute ： 0 - 59 分钟。
second ： 0 - 59 秒。
start_date ： datetime 类型或者字符串类型，起始时间。
end_date ： datetime 类型或者字符串类型，结束时间。
timezone ：时区。
jitter ：任务触发的误差时间。
也可以用表达式类型，可以用以下方式：

表达式	字段	描述
*	任何	在每个值都触发
*/a	任何	每隔 a触发一次
a-b	任何	在 a-b区间内任何一个时间触发（ a必须小于 b）
a-b/c	任何	在 a-b区间内每隔 c触发一次
xth y	day	第 x个星期 y触发
lastx	day	最后一个星期 x触发
last	day	一个月中的最后一天触发
x,y,z	任何	可以把上面的表达式进行组合

示例：

def cron_task :
	scheduler = BlockingScheduler
	scheduler.add_job ( tick , "cron" , day = "4th sun" , hour = 20 , minute = 1 )
	scheduler.start

调度器

BlockingScheduler ：适用于调度程序是进程中唯一运行的进程，调用 start 函数会阻塞当前线程，不能立即返回。
BackgroundScheduler ：适用于调度程序在应用程序的后台运行，调用 start 后主线程不会阻塞。
AsyncIOScheduler ：适用于使用了 asyncio 模块的应用程序。
GeventScheduler ：适用于使用 gevent 模块的应用程序。
TwistedScheduler ：适用于构建 Twisted 的应用程序。
QtScheduler ：适用于构建 Qt 的应用程序

任务存储器

任务存储器的选择有两种。一是内存，也是默认的配置。二是数据库。使用内存的方式是简单高效，但是不好的是，一旦程序出现问题，重新运行的话，会把之前已经执行了的任务重新执行一遍。数据库则可以在程序崩溃后，重新运行可以从之前中断的地方恢复正常运行。有以下几种选择：

MemoryJobStore ：没有序列化，任务存储在内存中，增删改查都是在内存中完成。
SQLAlchemyJobStore ：使用 SQLAlchemy 这个 ORM 框架作为存储方式。
MongoDBJobStore ：使用 mongodb 作为存储器。
RedisJobStore ：使用 redis 作为存储器。

执行器

执行器的选择取决于应用场景。通常默认的 ThreadPoolExecutor已经在大部分情况下是可以满足我们需求的。如果我们的任务涉及到一些 CPU密集计算的操作。那么应该考虑 ProcessPoolExecutor。然后针对每种程序， apscheduler也设置了不同的 executor：

ThreadPoolExecutor ：线程池执行器。
ProcessPoolExecutor ：进程池执行器。
GeventExecutor ： Gevent 程序执行器。
TornadoExecutor ： Tornado 程序执行器。
TwistedExecutor ： Twisted 程序执行器。
AsyncIOExecutor ： asyncio 程序执行器。

定时任务调度配置

这里我们用一个例子来说明。比如我想这样配置

执行器：
配置 default 执行器为 ThreadPoolExecutor ，并且设置最多的线程数是20个。
存储器：
配置 default 的任务存储器为 SQLAlchemyJobStore (使用 SQLite ) 。
任务配置：
设置 coalesce 为 False ：设置这个目的是，比如由于某个原因导致某个任务积攒了很多次没有执行（比如有一个任务是1分钟跑一次，但是系统原因断了5分钟），如果 coalesce = True ，那么下次恢复运行的时候，会只执行一次，而如果设置 coalesce = False ，那么就不会合并，会5次全部执行。
max_instances = 5 ：同一个任务同一时间最多只能有5个实例在运行。比如一个耗时10分钟的job，被指定每分钟运行1次，如果我 max_instance 值5，那么在第 6 ~ 10 分钟上，新的运行实例不会被执行，因为已经有5个实例在跑了。

那么代码如下：

from apscheduler . schedulers . blocking import BlockingScheduler
from datetime import datetime
from apscheduler . jobstores . sqlalchemy import SQLAlchemyJobStore
from apscheduler . executors . pool import ThreadPoolExecutor
def interval_task :
	jobstores = {
	'default' : SQLAlchemyJobStore ( url = 'sqlite:///jobs.sqlite' )
	}   # 会自动在当前目录创建该sqlite文件
	executors = {
	'default' : ThreadPoolExecutor ( 20 )
	}  # 派生线程的最大数目
	job_defaults = {
	'coalesce' : False ,
	'max_instances' : 3
	}
	scheduler = BlockingScheduler ( jobstores = jobstores , executors = executors , job_defaults = job_defaults )
	scheduler.add_job ( tick , "interval" , minutes = 1 )
	scheduler.start

任务操作

添加任务：
使用 scheduler.add_job(job_obj,args,id,trigger,**trigger_kwargs)。
删除任务：
使用 scheduler.remove_job(job_id,jobstore=None)。
暂停任务：
使用 scheduler.pause_job(job_id,jobstore=None)。
恢复任务：
使用 scheduler.resume_job(job_id,jobstore=None)。
修改某个任务属性信息：
使用 scheduler.modify_job(job_id,jobstore=None,**changes)。
修改单个作业的触发器并更新下次运行时间：
使用 scheduler.reschedule_job(job_id,jobstore=None,trigger=None,**trigger_args)
输出作业信息：
使用 scheduler.print_jobs(jobstore=None,out=sys.stdout)

异常监听

当我们的任务抛出异常后，我们可以监听到，然后把错误信息进行记录。示例代码如下：

from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.events import EVENT_JOB_EXECUTED , EVENT_JOB_ERROR
import datetime
import logging

# 配置日志显示
logging.basicConfig ( level = logging . INFO ,
format = '%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s' ,
datefmt = '%Y-%m-%d %H:%M:%S' ,
filename = 'log1.txt' ,
filemode = 'a' )

def aps_test ( x ):
	print ( datetime . datetime . now . strftime ( '%Y-%m-%d %H:%M:%S' ), x )

def date_test ( x ):
	print ( datetime . datetime . now . strftime ( '%Y-%m-%d %H:%M:%S' ), x )

# 故意抛出异常
print ( 1 / 0 )
def my_listener ( event ):
	if event.exception :
		print ( '任务出错了！！！！！！' )
	else :
		print ( '任务照常运行...' )

scheduler = BlockingScheduler
scheduler.add_job ( func = date_test , args =( '一次性任务,会出错' ,), next_run_time = datetime.datetime . now + datetime . timedelta ( seconds = 15 ), id = 'date_task' )
scheduler.add_job ( func = aps_test , args =( '循环任务' ,), trigger = 'interval' , seconds = 3 , id = 'interval_task' )
# 配置任务执行完成和执行错误的监听
scheduler.add_listener ( my_listener , EVENT_JOB_EXECUTED | EVENT_JOB_ERROR )
# 设置日志
scheduler._logger = logging
schedule.start