python中BackgroundScheduler和BlockingScheduler的区别是什么

本篇内容介绍了“python中BackgroundScheduler和BlockingScheduler的区别是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

目录

• 基本的定时调度
  

• BlockingScheduler与BackgroundScheduler区别
  

APScheduler最基本的用法： “定时几秒后启动job”
两种调度器： BackgroundScheduler和BlockingScheduler的区别，
job执行时间大于定时调度时间特殊情况的问题及解决方法
每个job都会以thread的方式被调度。

1、基本的定时调度

APScheduler是python的一个定时任务调度框架，能实现类似linux下crontab类型的任务，使用起来比较方便。它提供基于固定时间间隔、日期以及crontab配置类似的任务调度，并可以持久化任务，或将任务以daemon方式运行。

下面是一个最基本的使用示例：

from apscheduler.schedulers.blocking import BlockingSchedulerdef job():    print('job 3s')if __name__=='__main__':    sched = BlockingScheduler(timezone='MST')    sched.add_job(job, 'interval', id='3_second_job', seconds=3)    sched.start()

它能实现每隔3s就调度job()运行一次，所以程序每隔3s就输出'job 3s'。通过修改add_job()的参数seconds，就可以改变任务调度的间隔时间。

2、BlockingScheduler与BackgroundScheduler区别

APScheduler中有很多种不同类型的调度器，BlockingScheduler与BackgroundScheduler是其中最常用的两种调度器。那他们之间有什么区别呢？ 简单来说，区别主要在于BlockingScheduler会阻塞主线程的运行，而BackgroundScheduler不会阻塞。所以，我们在不同的情况下，选择不同的调度器：

BlockingScheduler: 调用start函数后会阻塞当前线程。当调度器是你应用中唯一要运行的东西时（如上例）使用。
BackgroundScheduler: 调用start后主线程不会阻塞。当你不运行任何其他框架时使用，并希望调度器在你应用的后台执行。
下面用两个例子来更直观的说明两者的区别。

BlockingScheduler例子

from apscheduler.schedulers.blocking import BlockingSchedulerimport timedef job():    print('job 3s')if __name__=='__main__':    sched = BlockingScheduler(timezone='MST')    sched.add_job(job, 'interval', id='3_second_job', seconds=3)    sched.start()    while(True): # 不会被执行到        print('main 1s')        time.sleep(1)

运行这个程序，我们得到如下的输出：

job 3s
job 3s
job 3s
job 3s 

可见，BlockingScheduler调用start函数后会阻塞当前线程，导致主程序中while循环不会被执行到。

BackgroundScheduler例子

from apscheduler.schedulers.background import BackgroundSchedulerimport timedef job():    print('job 3s')if __name__=='__main__':    sched = BackgroundScheduler(timezone='MST')    sched.add_job(job, 'interval', id='3_second_job', seconds=3)    sched.start()    while(True):        print('main 1s')        time.sleep(1)

可见，BackgroundScheduler调用start函数后并不会阻塞当前线程，所以可以继续执行主程序中while循环的逻辑。

main 1s
main 1s
main 1s
job 3s
main 1s
main 1s
main 1s
job 3s 

通过这个输出，我们也可以发现，调用start函数后，job()并不会立即开始执行。而是等待3s后，才会被调度执行。
如何让job在start()后就开始运行
如何才能让调度器调用start函数后，job()就立即开始执行呢？

其实APScheduler并没有提供很好的方法来解决这个问题，但有一种最简单的方式，就是在调度器start之前，就运行一次job()，如下

from apscheduler.schedulers.background import BackgroundSchedulerimport timedef job():    print('job 3s')if __name__=='__main__':    job() # 执行一次就好了哟    sched = BackgroundScheduler(timezone='MST')    sched.add_job(job, 'interval', id='3_second_job', seconds=3)    sched.start()    while(True):        print('main 1s')        time.sleep(1)

这样就能得到如下的输出

job 3s
main 1s
main 1s
main 1s
job 3s
main 1s
main 1s
main 1s

这样虽然没有绝对做到“让job在start()后就开始运行”，但也能做到“不等待调度，而是刚开始就运行job”。

如果job执行时间过长会怎么样
如果执行job()的时间需要5s，但调度器配置为每隔3s就调用一下job()，会发生什么情况呢？我们写了如下例子：

from apscheduler.schedulers.background import BackgroundSchedulerimport timedef job():    print('job 3s')    time.sleep(5)if __name__=='__main__':    sched = BackgroundScheduler(timezone='MST')    sched.add_job(job, 'interval', id='3_second_job', seconds=3)    sched.start()    while(True):        print('main 1s')        time.sleep(1)

运行这个程序，我们得到如下的输出：

main 1s
main 1s
main 1s
job 3s
main 1s
main 1s
main 1s
Execution of job "job (trigger: interval[0:00:03], next run at: 2018-05-07 02:44:29 MST)" skipped: maximum number of running instances reached (1)
main 1s
main 1s
main 1s
job 3s
main 1s

可见，3s时间到达后，并不会“重新启动一个job线程”，而是会跳过该次调度，等到下一个周期（再等待3s），又重新调度job()。

为了能让多个job()同时运行，我们也可以配置调度器的参数max_instances，如下例，我们允许2个job()同时运行：

from apscheduler.schedulers.background import BackgroundSchedulerimport timedef job():    print('job 3s')    time.sleep(5)if __name__=='__main__':    job_defaults = { 'max_instances': 2 }    sched = BackgroundScheduler(timezone='MST', job_defaults=job_defaults)    sched.add_job(job, 'interval', id='3_second_job', seconds=3)    sched.start()    while(True):        print('main 1s')        time.sleep(1)

运行程序，我们得到如下的输出：

main 1s
main 1s
main 1s
job 3s
main 1s
main 1s
main 1s
job 3s
main 1s
main 1s
main 1s
job 3s

每个job是怎么被调度的

通过上面的例子，我们发现，调度器是定时调度job()函数，来实现调度的。

那job()函数会被以进程的方式调度运行，还是以线程来运行呢？

为了弄清这个问题，我们写了如下程序：

from apscheduler.schedulers.background import BackgroundSchedulerimport time,os,threadingdef job():    print('job thread_id-{0}, process_id-{1}'.format(threading.get_ident(), os.getpid()))    time.sleep(50)if __name__=='__main__':    job_defaults = { 'max_instances': 20 }    sched = BackgroundScheduler(timezone='MST', job_defaults=job_defaults)    sched.add_job(job, 'interval', id='3_second_job', seconds=3)    sched.start()    while(True):        print('main 1s')        time.sleep(1)

运行程序，我们得到如下的输出：

main 1s
main 1s
main 1s
job thread_id-10644, process_id-8872
main 1s
main 1s
main 1s
job thread_id-3024, process_id-8872
main 1s
main 1s
main 1s
job thread_id-6728, process_id-8872
main 1s
main 1s
main 1s
job thread_id-11716, process_id-8872

可见，每个job()的进程ID都相同，但线程ID不同。所以，job()最终是以线程的方式被调度执行。

“python中BackgroundScheduler和BlockingScheduler的区别是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站，小编将为大家输出更多高质量的实用文章！