使用threading模块中的Timer函数

from threading import Timer
import time def execute_func(name, age, gender, hobby):
print(f"name is {name}, age is {age}, gender is {gender}, hobby is {hobby}") def start_func():
# Timer接收的参数是:interval, function, args=None, kwargs=None
# interval:时间间隔,一个数字,表示多少秒后执行
# function:函数,要执行的函数
# args:位置参数
# kwargs:关键字参数
t = Timer(3, execute_func, args=("satori", 10), kwargs={"gender": "f", "hobby": "animal"})
# 调用start之后启动,并且不会阻塞,因为单独开启了一个线程
t.start()
time.sleep(5)
print("在我打印之前,execute_func函数就已经被执行完毕了") start_func()

运行结果

name is satori, age is 10, gender is f, hobby is animal
在我打印之前,execute_func函数就已经被执行完毕了

使用schedule模块

import schedule

def foo():
print(123) # 每隔3秒钟运行foo,如果有参数,直接通过args= 或者kwargs=进行传参即可
schedule.every(3).seconds.do(foo)
# 每隔1秒钟运行foo
schedule.every().seconds.do(foo)
# 每隔1分钟运行foo
schedule.every().minutes.do(foo)
# 每隔一小时运行foo
schedule.every().hours.do(foo)
# 每隔一天运行foo
schedule.every().days.do(foo)
# 每隔一星期运行foo
schedule.every().weeks.do(foo)
# 每隔3到5秒钟运行foo
schedule.every(3).to(5).seconds.do(foo)
# 每隔3到5天运行foo
schedule.every(3).to(5).days.do(foo) # 每天在10:30的时候运行foo
schedule.every().days.at("10:30").do(foo)
# 每周一的时候运行foo
schedule.every().monday.do(foo)
# 每周日晚上11点的时候运行foo
schedule.every().sunday.at("23:00").do(foo)
while True:
# 保持schedule一直运行,然后去查询上面的任务
schedule.run_pending()
import schedule
import time def foo1():
time.sleep(2)
print(time.perf_counter() - start_time) def foo2():
time.sleep(2)
print(time.perf_counter() - start_time) schedule.every(5).seconds.do(foo1)
schedule.every(5).seconds.do(foo2) start_time = time.perf_counter()
while 1:
schedule.run_pending()

运行结果

7.000133540999999
9.000496485
14.001490562999999
16.002477991
21.002556953
23.003146251
28.003308606
30.003953593

注意到:运行时间是每隔七秒后,由于任务本身也占用了时间。可以考虑使用多线程

import schedule
import time
import threading def foo1():
time.sleep(2)
print(time.perf_counter() - start_time) def foo2():
time.sleep(2)
print(time.perf_counter() - start_time) def t1():
t = threading.Thread(target=foo1)
t.start() def t2():
t = threading.Thread(target=foo2)
t.start() schedule.every(5).seconds.do(t1)
schedule.every(5).seconds.do(t2) start_time = time.perf_counter()
while 1:
schedule.run_pending()

运行结果

7.006393073
7.006451532000001
12.007217038999999
12.012260847999999
17.00669922
17.012707463
22.008171498000003
22.008225246000002

可以看到这次变成每隔5秒执行了,而且两个任务之间也没有2s的间隔了

apscheduler模块用法


关于定时任务的实现,还有python自带的threading.Timer和schedule模块,但是功能不强,这里就不写了。

apscheduler提供了基于日期、时间间隔、以及crontab类型的任务,我们可以在主程序的运行过程中快速增加新任务或者删除旧任务,如果把任务存储在数据库中,那么任务的状态会被保存。当调度器重启时,不必重新添加任务,保存起来的任务会恢复原状态继续执行

基础概念

apscheduler有以下几个重要的组件

触发器(triggers):触发器包含调度逻辑,描述一个任务何时被触发,按照日期、时间间隔、cron表达式,三种方式触发。每个作业都有其自己的触发器,除了初始配置之外,触发器是完全无状态的。

任务存储器(job stores):任务存储器指定了作业被存放的位置,默认情况下任务保存在内存,也可以将任务保存在数据库中,当任务被保存在数据库中,它会被序列化;当被重新加载到内存中,会被反序列化。任务存储器充当保存、加载、更新和查找任务的中间商。在调度器之间不能共享任务存储。

执行器(executors):执行器是将指定的任务(调用函数)放到线程池或进程池当中去运行,当任务完成时,执行器通知调度器触发相应的事件

调度器(schedulers):任务调度器,属于控制角色,通过它配置任务存储器、执行器和触发器,添加、修改和删除任务。调度器协调触发器、任务存储器、执行器的运行,通常只有一个调度程序运行在应用程序中,开发人员通常不需要直接处理任务存储器、执行器或者触发器,配置任务存储器和执行器都是通过调度器来完成的。


调度器组件

  • BlockingScheduler 阻塞式调度器:适用于只跑调度器的程序。
  • BackgroundScheduler 后台调度器:适用于非阻塞的情况,调度器会在后台独立运行。
  • AsyncIOScheduler AsyncIO调度器,适用于应用使用AsnycIO的情况。
  • TornadoScheduler Tornado调度器,适用于构建Tornado应用。
  • TwistedScheduler Twisted调度器,适用于构建Twisted应用。
  • QtScheduler Qt调度器,适用于构建Qt应用。

任务存储器的选择,要看任务是否需要持久化。如果任务是无状态的,那么选择默认存储器MemoryJobStore就可以应付。但是,如果需要程序关闭或者重启时,保持任务的状态,那么就要选择持久化的任务存储器。另外,作者推荐,使用SQLAlchemyJobStore并搭配PostgreSQL作为后台数据库。这个方案可以提供强大的数据整合与保护功能。

执行器的选择,同样看需求。默认的ThreadPoolExecutor线程池执行器方案可以满足大部分需求。如果,你的程序是计算密集型的,那么最好用ProcessPoolExecutor进程池执行器方案来充分利用多核算力。也可以将ProcessPoolExecutor作为第二执行器,混合使用两种不同的执行器。

配置一个任务,就要设置一个任务触发器。触发器可以设定任务运行的周期、次数和时间。APScheduler有三种内置的触发器:

  • date 日期:触发任务运行的具体日期
  • interval 间隔:触发任务运行的时间间隔
  • cron 周期:触发任务运行的周期

一个任务也可以设定多种触发器,比如,可以设定同时满足所有触发器条件而触发,或者满足一项即触发。


触发器

date 在指定时间点触发任务

from datetime import date, datetime
from apscheduler.schedulers.blocking import BlockingScheduler # 选择了阻塞式调度器,创建一个调度器的实例
scheduler = BlockingScheduler() # 创建一个任务
def my_task(name, age, gender):
print(f"name is {name}, age is {age}, gender is {gender}") # 通过调用调度实例下的add_job方法,将任务添加进去
"""
常用参数:
func:任务(执行函数)
trigger:触发器,一共三种方式。
date 日期:触发任务运行的具体日期
interval 间隔:触发任务运行的时间间隔
cron 周期:触发任务运行的周期
run_date:运行日期,当我们指定trigger为'date'时,可以添加这么一个参数。类型可以是date、datetime、以及文本类型
args:任务的位置参数
kwargs:任务的关键字参数
"""
scheduler.add_job(my_task, trigger="date",
run_date=date(2019, 6, 10),
args=("mashiro", 17),
kwargs={"gender": "女"}) scheduler.add_job(my_task,
trigger="date",
run_date=datetime(2019, 6, 9, 17, 14, 4),
args=("mashiro", 17),
kwargs={"gender": "女"}) scheduler.add_job(my_task,
trigger="date",
run_date="2019-6-9 17:14:05",
args=("mashiro", 17),
kwargs={"gender": "女"}) # 未指定日期,则会立即执行
scheduler.add_job(my_task,
args=("mashiro", 17),
kwargs={"gender": "女"}) # 启动调度器
scheduler.start()

运行结果

name is mashiro, age is 17, gender is 女
name is mashiro, age is 17, gender is 女
name is mashiro, age is 17, gender is 女

还有一个没有打印,程序没有结束。等打印的时候,要等到明天,也就是10号了。今天是9号

如果我把日期改一下呢?比如此刻是2019-6-9,我改成18年执行

Run time of job "my_task (trigger: date[2018-11-14 00:00:00 CST], next run at: 2018-11-14 00:00:00 CST)" was missed by 207 days, 17:18:14.146335

会提示如下,提前了这个任务比当前时间,少了207天,是在当前时间之前,是无法执行的。


interval 周期触发任务

from apscheduler.schedulers.blocking import BlockingScheduler

scheduler = BlockingScheduler()

def my_task1():
print("好きなものを仕事にしたことは実に人生の一つ楽しいこと") def my_task2():
print("把喜欢的东西变成工作实乃人生一大快事") # 其他参数没什么变化,当我们把trigger指定成interval的时候,表示每隔xx时间执行一次。可以额外指定如下参数
"""
weeks:每隔多少周后执行一次
days:每隔多少天后执行一次
hours:每隔多少小时后执行一次
minutes:每隔多少分钟后执行一次
seconds:每隔多少秒后执行一次
此外还可以指定start_date,和end_date。表示任务触发的起始时间和结束时间。
比如某个任务每隔一天执行一次,但是这个任务有截止日期,当超过了截止日期的时候,就不需要再执行它了。于是就可以将该"截止日期"设置为end_date,如果超过了,那么任务会被取消掉
""" # 此时的时间已经超过了2019-6-9 17:32:00,所以第二个任务是会被取消掉的。
scheduler.add_job(func=my_task1, trigger="interval", minutes=1)
scheduler.add_job(func=my_task2, trigger="interval", minutes=1, end_date="2019-6-9 17:43:00") scheduler.start()

运行结果

好きなものを仕事にしたことは実に人生の一つ楽しいこと
把喜欢的东西变成工作实乃人生一大快事
好きなものを仕事にしたことは実に人生の一つ楽しいこと
把喜欢的东西变成工作实乃人生一大快事
好きなものを仕事にしたことは実に人生の一つ楽しいこと
把喜欢的东西变成工作实乃人生一大快事
好きなものを仕事にしたことは実に人生の一つ楽しいこと
把喜欢的东西变成工作实乃人生一大快事
好きなものを仕事にしたことは実に人生の一つ楽しいこと
好きなものを仕事にしたことは実に人生の一つ楽しいこと
好きなものを仕事にしたことは実に人生の一つ楽しいこと
。。。。。。
。。。。。。
。。。。。。
from apscheduler.schedulers.blocking import BlockingScheduler
import time scheduler = BlockingScheduler() # 另外还有一个jitter参数,表示添加一个随机的浮动秒数。
# 当所有任务全部都在一起执行的时候,可能造成服务器资源压力大,那么添加一个随机秒数,可以避免造成服务拥堵。 # 除了add_job的方式,我们还可以通过scheduled_job使用装饰器的方式
t1 = time.perf_counter()
@scheduler.scheduled_job(trigger="interval", seconds=10, jitter=1)
def my_task():
print("好きなものを仕事にしたことは実に人生の一つ楽しいこと", time.perf_counter() - t1) scheduler.start()

运行结果

好きなものを仕事にしたことは実に人生の一つ楽しいこと 10.900859013
好きなものを仕事にしたことは実に人生の一つ楽しいこと 19.972885888
好きなものを仕事にしたことは実に人生の一つ楽しいこと 30.506739256000003
。。。。。。

cron

当把trigger指定为cron的时候,可以达到非常强大的效果,该表达式被定义为一个类:

apscheduler.triggers.cron.CronTrigger

"""
class CronTrigger:
def __init__(self, year=None, month=None, day=None, week=None, day_of_week=None, hour=None,
minute=None, second=None, start_date=None, end_date=None, timezone=None,
jitter=None):
year:四位数的年份
month:1-12之间的数字或字符串,如果不指定,则为*,表示每个月
day:1-31,如果不指定,则为*,表示每一天
week:1-53,如果不指定,则为*,表示每一星期
day_of_week:一周有7天,用0-6表示,比如指定0-3,则表示周一到周四。不指定则为7天,也可以用 mon,tue,wed,thu,fri,sat,sun表示
hour:0-23
minute:0-59
second:0-59
start_date:起始时间
end_date:结束时间
timezone:时区
jitter:随机的浮动秒数
当省略时间参数时,在显式指定参数之前的参数会被设定为*,表示每(月、天)xxx。之后的参数会被设定为最小值,week 和day_of_week的最小值为*。
比如,设定day=10等同于设定year='*', month='*', day=1, week='*', day_of_week='*', hour=0, minute=0, second=0,
即每个月的第10天触发。为什么是每个月而不是每个星期,注意参数位置,week被放在了后面。day后面的参数hour、minute、second则被设置为0。因此不仅是每个月的第10天触发,还是每个月的第10天的00:00:00的时候触发
"""

表达式类型

表达式 参数类型 描述
* 所有 通配符。例:minutes=*即每分钟触发
*/a 所有 可被a整除的通配符。
a-b 所有 范围a-b触发
a-b/c 所有 范围a-b,且可被c整除时触发
xth y 第几个星期几触发。x为第几个,y为星期几
last x 一个月中,最后个星期几触发
last 一个月最后一天触发
x,y,z 所有 组合表达式,可以组合确定值或上方的表达式

hour =19 ,minute =23 这里表示每个月的每一天在过了19小时23分钟(即19:23)的时候执行任务。因为显式指定的参数的前面的参数都被设置为*,表示每

hour ='19', minute ='23',可以填字符串也可以填数字

month='6-9,11-12', day='4rd sun', hour='0-3' 表示将在第6、7、8、9、11、12个月的第四个星期日的00:00:00、01:00:00、02:00:00、03:00:00执行任务。

day=15, hour=20,minute=14 表示每个月的第15天的20:14的时候执行任务

day='4rd sun' 表示将在每个月的第四个周日执行任务,而且是00:00:00,因为后面的参数如果不指定的话,默认为最小值。

day=''last sun", hour=17, minute=25 表示每个月的最后一个星期日的17:25执行任务

day="last", hour=20 表示每个月的最后一天的20:00的时候执行任务

day_of_week="0-2" 表示每一周的周一、周二、周三执行任务

month="1-3", day_of_week="mon", hour="22", minute="14", second="48" 表示1月、2月、3月的每个星期1的22:14:48的时候执行任务。

因此值得注意的是:day既可以写数字表示每个月的第xxx天,也可以写xth y表示每个月的第x个星期y、last x表示最后一个星期x、last表示每个月的最后一天。而如果想表示每个月的每个星期几,则可以使用day_of_week='0-6'(每周一到周日,或者写成mon-sun),day_of_week='0-4'(每周一到周五),day_of_week='0'(每周一)。一般情况:day和day_of_week不建议同时使用。

夏令时问题

有些timezone时区可能会有夏令时的问题。这个可能导致令时切换时,任务不执行或任务执行两次。因此可以指定timezone

from apscheduler.schedulers.blocking import BlockingScheduler
import pytz
import datetime
timezone = pytz.timezone("Asia/Shanghai") def my_task():
print("task executed")
print(datetime.datetime.now()) scheduler = BlockingScheduler()
# 第6个月的第9天的每小时第3分钟第30秒执行,同时指定时区
scheduler.add_job(my_task, trigger="cron", month=6, day=9, minute=3, second=30, timezone=timezone) scheduler.start()

运行结果

task executed
2019-06-09 19:03:30.001664

配置调度器

APScheduler 有多种不同的配置方法,可以选择直接传字典或传参的方式创建调度器;也可以先实例一个调度器对象,再添加配置信息。灵活的配置方式可以满足各种应用场景的需要。

整套的配置选项可以参考API文档BaseScheduler类。一些调度器子类可能有它们自己特有的配置选项,以及独立的任务储存器和执行器也可能有自己特有的配置选项,可以查阅API文档了解。

from apscheduler.schedulers.background import BackgroundScheduler

# 创建一个后台调度器实例,该实例是非阻塞的
scheduler = BackgroundScheduler()
"""
该调度器下有一个名称为default的MemoryJobStore(内存任务储存器)和一个名称是default且最大线程是10的ThreadPoolExecutor(线程池执行器)
"""

但现在我需要自己指定任务存储器和执行器该怎么办呢?比如我要将任务存储器设置为Pgsql和redis,线程池设置为20个,同时搭配5个进程池。

方法一

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.jobstores.redis import RedisJobStore
from apscheduler.executors.pool import ThreadPoolExecutor, ProcessPoolExecutor
import pytz jobstores = {
"redis": RedisJobStore(hostname="localhost", port=6379),
"sqlalchemy_pgsql": SQLAlchemyJobStore(url="postgresql://localhost:5432@postgres:zgghyys123/postgres")
} executors = {
"thread_pool": ThreadPoolExecutor(20),
"process_pool": ProcessPoolExecutor(5)
} job_defaults = {
"coalesce": False, # 默认为新任务关闭合并模式
"max_instances": 3, # 设置新任务的最大实例数为3
} scheduler = BackgroundScheduler(jobstores=jobstores,
executors=executors,
job_defaults=job_defaults,
timezone=pytz.utc)

方法二

from apscheduler.schedulers.background import BackgroundScheduler

scheduler = BackgroundScheduler({
"apscheduler.jobstores.redis": {
"type": "redis",
"hostname": "localhost",
"port": 6379
}, "apscheduler.jobstores.sqlalchemy_pgsql": {
"type": "sqlalchemy",
"url": "postgresql://localhost:5432@postgres:zgghyys123/postgres"
}, "apscheduler.executors.thread_pool": {
"type": "apscheduler.executors.pool:ThreadPoolExecutor",
"max_workers": 20
}, "apscheduler.executors.process_pool": {
"type": "apscheduler.executors.pool:ProcessPoolExecutor",
"max_workers": 5
}, "apscheduler.job_defaults.coalesce": "false",
"apscheduler.job_defaults.max_instances": "3",
"apscheduler.timezone": "UTC"
})

方法三

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.jobstores.redis import RedisJobStore
from apscheduler.executors.pool import ThreadPoolExecutor, ProcessPoolExecutor
import pytz jobstores = {
"redis": RedisJobStore(hostname="localhost", port=6379),
"sqlalchemy_pgsql": SQLAlchemyJobStore(url="postgresql://localhost:5432@postgres:zgghyys123/postgres")
} executors = {
"thread_pool": ThreadPoolExecutor(20),
"process_pool": ProcessPoolExecutor(5)
} job_defaults = {
"coalesce": False, # 默认为新任务关闭合并模式
"max_instances": 3, # 设置新任务的最大实例数为3
} scheduler = BackgroundScheduler()
scheduler.configure(jobstores=jobstores,
executors=executors,
job_defaults=job_defaults,
timezone=pytz.utc)

以上为自定义调度器的三种方法,推荐第一种或第三种,第二种太麻烦。


启动调度器

启动调度器只需要调用start方法即可,除了BlockingScheduler,非阻塞调度器都会立即返回,可以继续运行之后的代码,比如添加任务等。

对于BlockingScheduler,程序则会阻塞在start()位置,所以,要运行的代码必须写在start()之前。

注!调度器启动后,就不能修改配置了。


添加任务

添加任务的方法有两种:

  • 通过调用add_job方法。最常用
  • 通过scheduled_job方法,最方便,但缺点就是运行时不能修改任务。第一种add_job方法会返回一个apscheduler.job.Job实例,这样就可以在运行时,修改或删除任务。

任何时候你都能配置任务。但是如果调度器还没有启动,此时添加任务,那么任务就处于一个暂存的状态。只有当调度器启动时,才会开始计算下次运行时间。

还有一点要注意,如果你的执行器或任务储存器是会序列化任务的,那么这些任务就必须符合:

  1. 回调函数必须全局可用
  2. 回调函数参数必须也是可以被序列化的

内置任务储存器中,只有MemoryJobStore不会序列化任务;内置执行器中,只有ProcessPoolExecutor会序列化任务。

重要提醒!
如果在程序初始化时,是从数据库读取任务的,那么必须为每个任务定义一个明确的ID,并且使用replace_existing=True,否则每次重启程序,你都会得到一份新的任务拷贝,也就意味着任务的状态不会保存。
建议
如果想要立刻运行任务,可以在添加任务时省略trigger参数
import datetime
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.executors.pool import ThreadPoolExecutor
import pytz jobstores = {
"sqlalchemy_pgsql": SQLAlchemyJobStore(url="postgresql://postgres:zgghyys123@localhost:5432/postgres")
} executors = {
"thread_pool": ThreadPoolExecutor(3),
} job_defaults = {
"coalesce": False, # 默认为新任务关闭合并模式
"max_instances": 3, # 设置新任务的最大实例数为3
} scheduler = BackgroundScheduler(jobstores=jobstores,
executors=executors,
job_defaults=job_defaults,
timezone=pytz.timezone("Asia/Shanghai")) def my_task1():
print("task1_executed", f"now is {datetime.datetime.now()}") def my_task2():
print("task2_executed", f"now is {datetime.datetime.now()}") def my_task3():
print("task3_executed", f"now is {datetime.datetime.now()}") scheduler.add_job(my_task1, trigger="cron", second=10, id="my_task1")
scheduler.add_job(my_task2, trigger="cron", second=10, id="my_task2")
scheduler.add_job(my_task3, trigger="cron", second=10, id="my_task3") scheduler.start()
while 1:
pass

运行结果

task1_executed now is 2019-06-09 21:49:10.075890
task2_executed now is 2019-06-09 21:49:10.087858
task3_executed now is 2019-06-09 21:49:10.105834
task1_executed now is 2019-06-09 21:50:10.110394
task2_executed now is 2019-06-09 21:50:10.127318
task3_executed now is 2019-06-09 21:50:10.138316
task1_executed now is 2019-06-09 21:51:10.103801
task2_executed now is 2019-06-09 21:51:10.103801
task3_executed now is 2019-06-09 21:51:10.149701
。。。。。。。

此时数据库里面多了一张表,名叫apscheduler_jobs。保存了执行的状态,当我们重启启动程序的时候,会进行读取。

但是呢?每一次读取都是重新读取,也就是说状态不会被保存,如果想从数据库读取任务,从上一次中断的状态继续执行的话,那么必须要为任务制定id,同时设置replace_existing=True。


移除任务

如果想从调度器移除一个任务,那么你就要从相应的任务储存器中移除它,这样才算移除了。有两种方式:

  1. 调用remove_job(),参数为:任务ID,任务储存器名称
  2. 在通过add_job()创建的任务实例上调用remove()方法

第二种方式更方便,但前提必须在创建任务实例时,实例被保存在变量中。对于通过scheduled_job()创建的任务,只能选择第一种方式。

当任务调度结束时(比如,某个任务的触发器不再产生下次运行的时间),任务就会自动移除。

job = scheduler.add_job(myfunc, 'interval', minutes=2)
job.remove()

同样,通过任务的具体ID:

scheduler.add_job(myfunc, 'interval', minutes=2, id='my_job_id')
scheduler.remove_job('my_job_id')

暂停和恢复任务

通过任务实例或调度器,就能暂停和恢复任务。如果一个任务被暂停了,那么该任务的下一次运行时间就会被移除。在恢复任务前,运行次数计数也不会被统计。

暂停任务,有以下两个方法:

  • apscheduler.job.Job.pause()
  • apscheduler.schedulers.base.BaseScheduler.pause_job()

恢复任务

  • apscheduler.job.Job.resume()
  • apscheduler.schedulers.base.BaseScheduler.resume_job()

获取任务列表

通过get_jobs()就可以获得一个可修改的任务列表。get_jobs()第二个参数可以指定任务储存器名称,那么就会获得对应任务储存器的任务列表。

print_jobs()可以快速打印格式化的任务列表,包含触发器,下次运行时间等信息。

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.executors.pool import ThreadPoolExecutor
import pytz
import time jobstores = {
"sqlalchemy_pgsql": SQLAlchemyJobStore(url="postgresql://postgres:zgghyys123@localhost:5432/postgres")
} executors = {
"thread_pool": ThreadPoolExecutor(3),
} job_defaults = {
"coalesce": False, # 默认为新任务关闭合并模式
"max_instances": 3, # 设置新任务的最大实例数为3
} scheduler = BackgroundScheduler(jobstores=jobstores,
executors=executors,
job_defaults=job_defaults,
timezone=pytz.timezone("Asia/Shanghai")) def my_task1():
print("task1_prepared")
time.sleep(5)
print(f"task1_executed") def my_task2():
print("task2_prepared")
time.sleep(5)
print(f"task2_executed") def my_task3():
print("task3_prepared")
time.sleep(5)
print(f"task3_executed") scheduler.add_job(my_task1, trigger="interval", seconds=3, id="my_task1")
scheduler.add_job(my_task2, trigger="interval", seconds=3, id="my_task2")
scheduler.add_job(my_task3, trigger="interval", seconds=3, id="my_task3") scheduler.start()
print(scheduler.get_jobs())
scheduler.print_jobs()

运行结果

[<Job (id=my_task1 name=my_task1)>, <Job (id=my_task2 name=my_task2)>, <Job (id=my_task3 name=my_task3)>]
Jobstore default:
my_task1 (trigger: interval[0:00:03], next run at: 2019-06-09 22:35:23 CST)
my_task2 (trigger: interval[0:00:03], next run at: 2019-06-09 22:35:23 CST)
my_task3 (trigger: interval[0:00:03], next run at: 2019-06-09 22:35:23 CST)
Jobstore sqlalchemy_pgsql:
No scheduled jobs

修改任务

通过apscheduler.job.Job.modify()modify_job(),你可以修改任务当中除了id的任何属性。

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.executors.pool import ThreadPoolExecutor
import pytz
import time jobstores = {
"sqlalchemy_pgsql": SQLAlchemyJobStore(url="postgresql://postgres:zgghyys123@localhost:5432/postgres")
} executors = {
"thread_pool": ThreadPoolExecutor(3),
} job_defaults = {
"coalesce": False, # 默认为新任务关闭合并模式
"max_instances": 3, # 设置新任务的最大实例数为3
} scheduler = BackgroundScheduler(jobstores=jobstores,
executors=executors,
job_defaults=job_defaults,
timezone=pytz.timezone("Asia/Shanghai")) def my_task1():
print("task1_prepared")
time.sleep(5)
print(f"task1_executed") def my_task2():
print("task2_prepared")
time.sleep(5)
print(f"task2_executed") def my_task3():
print("task3_prepared")
time.sleep(5)
print(f"task3_executed") job1 = scheduler.add_job(my_task1, trigger="interval", seconds=10, id="my_task1")
job2 = scheduler.add_job(my_task2, trigger="interval", seconds=10, id="my_task2")
job3 = scheduler.add_job(my_task3, trigger="interval", seconds=10, id="my_task3") scheduler.start()
# 改变name
job3.modify(name="satori")
print(scheduler.get_jobs())
while 1:
pass
[<Job (id=my_task1 name=my_task1)>, <Job (id=my_task2 name=my_task2)>, <Job (id=my_task3 name=satori)>]

可以看到job的name被修改了

如果想要重新调度任务(就是改变触发器),你能通过apscheduler.job.Job.reschedule()reschedule_job()来实现。这些方法会重新创建触发器,并重新计算下次运行时间。

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.executors.pool import ThreadPoolExecutor
import pytz
import time jobstores = {
"sqlalchemy_pgsql": SQLAlchemyJobStore(url="postgresql://postgres:zgghyys123@localhost:5432/postgres")
} executors = {
"thread_pool": ThreadPoolExecutor(3),
} job_defaults = {
"coalesce": False, # 默认为新任务关闭合并模式
"max_instances": 3, # 设置新任务的最大实例数为3
} scheduler = BackgroundScheduler(jobstores=jobstores,
executors=executors,
job_defaults=job_defaults,
timezone=pytz.timezone("Asia/Shanghai")) def my_task1():
print("task1_prepared")
time.sleep(5)
print(f"task1_executed") def my_task2():
print("task2_prepared")
time.sleep(5)
print(f"task2_executed") def my_task3():
print("task3_prepared")
time.sleep(5)
print(f"task3_executed") job1 = scheduler.add_job(my_task1, trigger="interval", seconds=10, id="my_task1")
job2 = scheduler.add_job(my_task2, trigger="interval", seconds=10, id="my_task2")
job3 = scheduler.add_job(my_task3, trigger="interval", seconds=10, id="my_task3") scheduler.start()
# 通过id,改变trigger,改成6s后执行
scheduler.reschedule_job(job_id="my_task2", trigger="interval", seconds=6)
while 1:
pass

运行结果

task2_prepared
task1_prepared
task3_prepared
task2_executed
task2_prepared
task1_executed
task3_executed
.......

为什么会出现这个结果呢?首先task2在6s后就执行了,因此会先打印,task2_prepared。但是要sleep 5s,而task1和task3在10s后执行,所以只差了4s。因此在先打印完task1_prepared和task3_prepared之后,过1s打印task2_executed,此时task1和task3还差4s才能sleep结束。但是由于调度器修改,改成了3s,所以会再次先打印task2_prepared,然后又过了1s,才打印task1_executed和task3_executed


关闭调度器

scheduler.shutdown()

默认情况下,调度器会先把正在执行的任务处理完,再关闭任务储存器和执行器。但是,如果你就直接关闭,你可以添加参数:

scheduler.shutdown(wait=False)

上述方法不管有没有任务在执行,会强制关闭调度器。


暂停、恢复任务进程

调度器可以暂停正在执行的任务:

scheduler.pause()

也可以恢复任务:

scheduler.resume()

同时,也可以在调度器启动时,默认所有任务设为暂停状态。

scheduler.start(paused=True)

scheduler.remove_job(job_id,jobstore=None)#删除作业
scheduler.remove_all_jobs(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)#输出作业信息

限制任务执行的并行实例数

默认情况下,在同一时间,一个任务只允许一个执行中的实例在运行。比如说,一个任务是每5秒执行一次,但是这个任务在第一次执行的时候花了6秒,也就是说前一次任务还没执行完,后一次任务又触发了,由于默认一次只允许一个实例执行,所以第二次就丢失了。为了杜绝这种情况,可以在添加任务时,设置max_instances参数,为指定任务设置最大实例并行数。


丢失任务的执行与合并

有时,任务会由于一些问题没有被执行。最常见的情况就是,在数据库里的任务到了该执行的时间,但调度器被关闭了,那么这个任务就成了“哑弹任务”。错过执行时间后,调度器才打开了。这时,调度器会检查每个任务的misfire_grace_time参数int值,即哑弹上限,来确定是否还执行哑弹任务(这个参数可以全局设定的或者是为每个任务单独设定)。此时,一个哑弹任务,就可能会被连续执行多次。

但这就可能导致一个问题,有些哑弹任务实际上并不需要被执行多次。coalescing合并参数就能把一个多次的哑弹任务揉成一个一次的哑弹任务。也就是说,coalescingTrue能把多个排队执行的同一个哑弹任务,变成一个,而不会触发哑弹事件。

注!如果是由于线程池/进程池满了导致的任务延迟,执行器就会跳过执行。要避免这个问题,可以添加进程或线程数来实现或把 misfire_grace_time值调高。

假如一个作业本来 08:00 有一次执行,但是由于某种原因没有被调度上,现在 08:01 了,这个 08:00 的运行实例被提交时,会检查它预订运行的时间和当下时间的差值(这里是1分钟),大于我们设置的 30 秒限制,那么这个运行实例不会被执行。最常见的情形是 scheduler 被 shutdown 后重启,某个任务会积攒了好几次没执行,如 5 次,下次这个作业被提交给执行器时,执行 5 次。设置 coalesce=True 后,只会执行一次


调度器事件

调度器允许添加事件侦听器。部分事件会有特有的信息,比如当前运行次数等。add_listener(callback,mask)中,第一个参数是回调对象,mask是指定侦听事件类型,mask参数也可以是逻辑组合。回调对象会有一个参数就是触发的事件。

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.executors.pool import ThreadPoolExecutor
import pytz
from apscheduler.events import EVENT_JOB_EXECUTED, EVENT_JOB_ERROR jobstores = {
"sqlalchemy_pgsql": SQLAlchemyJobStore(url="postgresql://postgres:zgghyys123@localhost:5432/postgres")
} executors = {
"thread_pool": ThreadPoolExecutor(3),
} job_defaults = {
"coalesce": False, # 默认为新任务关闭合并模式
"max_instances": 3, # 设置新任务的最大实例数为3
} scheduler = BackgroundScheduler(jobstores=jobstores,
executors=executors,
job_defaults=job_defaults,
timezone=pytz.timezone("Asia/Shanghai")) def my_task1():
print("task1 executed") def my_task2():
raise IndexError
print("task2_executed") def my_task3():
print("task3_executed") def listener(event):
if event.exception:
print(f"{event.job_id}出错了")
else:
print(f"正常执行") job1 = scheduler.add_job(my_task1, trigger="interval", seconds=3, id="my_task1")
job2 = scheduler.add_job(my_task2, trigger="interval", seconds=3, id="my_task2")
job3 = scheduler.add_job(my_task3, trigger="interval", seconds=3, id="my_task3")
scheduler.add_listener(listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
scheduler.start()
while 1:
pass

运行结果

task1 executed
正常执行
task3_executed
正常执行
Job "my_task2 (trigger: interval[0:00:03], next run at: 2019-06-09 23:12:42 CST)" raised an exception
Traceback (most recent call last):
File "C:\python37\lib\site-packages\apscheduler\executors\base.py", line 125, in run_job
retval = job.func(*job.args, **job.kwargs)
File "D:/mashiro/9.py", line 33, in my_task2
raise IndexError
IndexError
my_task2出错了
task1 executed
正常执行
task3_executed
正常执行
Job "my_task2 (trigger: interval[0:00:03], next run at: 2019-06-09 23:12:45 CST)" raised an exception
Traceback (most recent call last):
File "C:\python37\lib\site-packages\apscheduler\executors\base.py", line 125, in run_job
retval = job.func(*job.args, **job.kwargs)
File "D:/mashiro/9.py", line 33, in my_task2
raise IndexError
IndexError

可以看到即使报错了,也会打印"my_task2出错了",但是这样不美观,我们指定一下日志


异常捕获

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.executors.pool import ThreadPoolExecutor
import pytz
from apscheduler.events import EVENT_JOB_EXECUTED, EVENT_JOB_ERROR
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') jobstores = {
"sqlalchemy_pgsql": SQLAlchemyJobStore(url="postgresql://postgres:zgghyys123@localhost:5432/postgres")
} executors = {
"thread_pool": ThreadPoolExecutor(3),
} job_defaults = {
"coalesce": False, # 默认为新任务关闭合并模式
"max_instances": 3, # 设置新任务的最大实例数为3
} scheduler = BackgroundScheduler(jobstores=jobstores,
executors=executors,
job_defaults=job_defaults,
timezone=pytz.timezone("Asia/Shanghai")) def my_task1():
print("task1 executed") def my_task2():
raise IndexError
print("task2_executed") def my_task3():
print("task3_executed") def listener(event):
if event.exception:
print(f"{event.job_id}出错了")
else:
print(f"正常执行") job1 = scheduler.add_job(my_task1, trigger="interval", seconds=3, id="my_task1")
job2 = scheduler.add_job(my_task2, trigger="interval", seconds=3, id="my_task2")
job3 = scheduler.add_job(my_task3, trigger="interval", seconds=3, id="my_task3")
scheduler.add_listener(listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
scheduler._logger = logging
scheduler.start()
while 1:
pass

运行结果

task1 executed
正常执行
task3_executed
正常执行
my_task2出错了
task1 executed
正常执行
task3_executed
正常执行
my_task2出错了
task1 executed
正常执行
my_task2出错了
task3_executed
正常执行
task1 executed
正常执行
task3_executed
正常执行
my_task2出错了

这样就能捕获异常消息了,而且在做成服务的时候。如果出错了,也可以以邮件的方式通知客户。

python中的定时任务的更多相关文章

  1. python中定时任务

    今天看网络框架时,突然想看一下定时器,于是往上搜索了一下python中timer task的实现,但是由于python本身对线程的支持不是太好,因为全局排它锁的存在,使得多线程在访问资源时效率比较低. ...

  2. Python中定时任务框架APScheduler

    前言 大家应该都知道在编程语言中,定时任务是常用的一种调度形式,在Python中也涌现了非常多的调度模块,本文将简要介绍APScheduler的基本使用方法. 一.APScheduler介绍 APSc ...

  3. Python中定时任务框架APScheduler的快速入门指南

    前言 大家应该都知道在编程语言中,定时任务是常用的一种调度形式,在Python中也涌现了非常多的调度模块,本文将简要介绍APScheduler的基本使用方法. 一.APScheduler介绍 APSc ...

  4. openstack中运行定时任务的两种方法及源代码分析

    启动一个进程,如要想要这个进程的某个方法定时得进行执行的话,在openstack有两种方式: 一种是通过继承 periodic_task.PeriodicTasks,另一种是使用loopingcall ...

  5. python中的轻量级定时任务调度库:schedule

    提到定时任务调度的时候,相信很多人会想到芹菜celery,要么就写个脚本塞到crontab中.不过,一个小的定时脚本,要用celery的话太“重”了.所以,我找到了一个轻量级的定时任务调度的库:sch ...

  6. python中的apscheduler模块

    1.简介 apscheduler是python中的任务定时模块,它包含四个组件:触发器(trigger),作业存储(job store),执行器(executor),调度器(scheduler). 2 ...

  7. Django中通过定时任务触发页面静态化的方式

    安装 pip install django-crontab 添加应用 INSTALLED_APPS = [ ... 'django_crontab', # 定时任务 ... ] 设置任务的定时时间 在 ...

  8. django中设置定时任务

    django中设置定时任务 在django中设置定时任务我们可以借用django-crontab这个第三包来实现 django-crontab只能在linux系统下使用 安装: pip install ...

  9. Python schedule 库定时任务

    Python schedule 库定时任务 schedule的使用 # 用于scrapy定时任务设置 import schedule import time def job(): print(&quo ...

随机推荐

  1. 01 numpy库(一)

    01-numpy NumPy(Numerical Python) 是 Python 语言的一个扩展程序库,支持大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库. NumPy 是一个运行 ...

  2. Jenkins初次启动卡住问题解决

    Jenkins在初次使用时, 一直卡住, 无论如何也不出现输入用户名密码. 忘记截图, 下次出现更新图示. 解决方案: 需要你进入Jenkins的工作目录,打开 hudson.model.Update ...

  3. Redis ==> 集群的三种模式

    一.主从同步/复制 通过持久化功能,Redis保证了即使在服务器重启的情况下也不会丢失(或少量丢失)数据,因为持久化会把内存中数据保存到硬盘上,重启会从硬盘上加载数据. 但是由于数据是存储在一台服务器 ...

  4. Spring学习之==>入门知识

    一.Spring是什么? Spring 是一种轻量级的.非侵入式的 Java/JavaEE 应用框架.Spring 使用的是基本的 JavaBean 来完成以前只可能由EJB完成的事情.然而,Spri ...

  5. Memtest86+ 5.0.1系统设置

    Settings: (1) Test Selection (测试选择) > (1) Default Tests (2) Skip Current Test (3) Select Test (4) ...

  6. JavaScript基础入门06

    目录 JavaScript 基础入门06 Math 对象 Math对象的静态属性 Math对象的静态方法 指定范围的随机数 返回随机字符 三角函数 Date对象 基础知识 日期对象具体API 构造函数 ...

  7. etcd 使用: golang 例子

    一:连接到 etcd package main import ( "fmt" "go.etcd.io/etcd/clientv3" "time&quo ...

  8. Docker 容器中搭建 nexus npm私库

    1,版本 dockers :1.13.1   :nexus 3 2,安装 docker pull liumiaocn/nexus 3,启动 项目 详细 Nexus UI 8081 private re ...

  9. 网络实验 04-利用三层交换机实现VLAN间路由

    利用三层交换机实现VLAN间路由 一.实验目标 掌握交换机Tag VLAN 的配置 掌握三层交换机基本配置方法 掌握三层交换机VLAN路由的配置方法 通过三层交换机实现VLAN间相互通信 二.实验背景 ...

  10. ORACLE 左连接 右连接 内连接 外连接 全连接 五中表连接方式

    1.左连接 :left join 2.右连接:right join 3.内连接:inner join 4.外连接:outer join 5.全连接:full join