Python实现定时任务的几种方式

一、while循环中使用sleep

缺点：不容易控制，而且是个阻塞函数
关于阻塞的解释可以看https://www.jianshu.com/p/47ee57646369

import time

def timer(n):
    '''''
    每n秒执行一次
    '''
    while True:
        print(time.strftime('%Y-%m-%d %X',time.localtime()))
        print("执行任务")  # 此处为要执行的任务
        time.sleep(n)

#五秒执行一次
timer(5)

#测试是否阻塞
print(“测试是否阻塞”)

注：while True一般是跟break语句共同出现的，为了跳出循环，循环体内部要用break语句，这里是定时循环任务，每隔一段时间执行一下任务，所以没使用break。

执行结果：
因为是while True阻塞函数，当前线程会被挂起，所以我后面的print是执行不到的

二、schedule模块

优点：可以管理和调度多个任务,可以进行控制
缺点：阻塞式函数

1、串行执行任务

import schedule
import time
import datetime

def job1():
    print('Job1:每隔10秒执行一次的任务，每次执行2秒')
    print('Job1-startTime:%s' %(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    time.sleep(2)
    print('Job1-endTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    print('------------------------------------------------------------------------')

def job2():
    print('Job2:每隔30秒执行一次，每次执行5秒')
    print('Job2-startTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    time.sleep(5)
    print('Job2-endTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    print('------------------------------------------------------------------------')


def job3():
    print('Job3:每隔1分钟执行一次，每次执行10秒')
    print('Job3-startTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    time.sleep(10)
    print('Job3-endTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    print('------------------------------------------------------------------------')


def job4():
    print('Job4:每天下午17:49执行一次，每次执行20秒')
    print('Job4-startTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    time.sleep(20)
    print('Job4-endTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    print('------------------------------------------------------------------------')


def job5():
    print('Job5:每隔5秒到10秒执行一次，每次执行3秒')
    print('Job5-startTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    time.sleep(3)
    print('Job5-endTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    print('------------------------------------------------------------------------')


if __name__ == '__main__':
    schedule.every(10).seconds.do(job1)
    schedule.every(30).seconds.do(job2)
    schedule.every(1).minutes.do(job3)
    schedule.every().day.at('17:49').do(job4)
    schedule.every(5).to(10).seconds.do(job5)
    while True:
        schedule.run_pending()

    # 测试是否阻塞
    print(“测试是否阻塞”)

schedule方法是串行的，也就是说，如果各个任务之间时间不冲突，那是没问题的；如果时间有冲突的话，例如到了该执行job2的时间，但此时job1还在执行中，便会串行的执行命令，等待job1执行完毕后再执行job2。

执行结果：
这里可以看到每个任务的执行起始到终止时间内都是单任务的，串行执行任务。

2、多线程执行任务

可以改为多线程的方式来执行任务，为每个任务创建一个线程，解决任务串行需要等待的问题

import schedule
import time
import threading
import datetime

def job():
    print('Job1-startTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    time.sleep(5)
    print('Job1-endTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))

def job2():
    print('Job2-startTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
    time.sleep(5)
    print('Job2-endTime:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))

def run_threaded(job_func):
     job_thread = threading.Thread(target=job_func)
     job_thread.start()

schedule.every(10).seconds.do(run_threaded,job)
schedule.every(10).seconds.do(run_threaded,job2)


while True:
    schedule.run_pending()
    
print("测试是否阻塞")

执行结果：
可以同步的执行每个任务，但还是while True还是阻塞的

三、sched模块

sched模块实现了一个时间调度程序，该程序可以通过单线程执行来处理按照时间尺度进行调度的时间。
通过调用scheduler.enter(delay,priority,func,args)函数，可以将一个任务添加到任务队列里面，当指定的时间到了，就会执行任务(func函数)。

串行执行调度器里的任务，需要等上一个任务执行完才执行其他的任务，如果有两个任务同时到达执行时间，根据设置的优先级先后执行。

调度器也是阻塞的，需要等待调度器里的任务都执行完才能往下接着运行。

• delay：任务的间隔时间。
• priority：如果几个任务被调度到相同的时间执行，将按照priority的增序执行这几个任务。
• func：要执行的任务函数
• args：func的参数

1、定时几秒后执行一次，执行后结束调度器

import time, sched
import datetime

#生成一个sched调度器示例
s = sched.scheduler(time.time, time.sleep)

#定义一个带a参数的操作函数，表示你要执行的操作
def print_time(a='default'):
    print('Now Time:',datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),a)

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

    #十秒后执行操作函数，优先级为1
    s.enter(10,1,print_time)
    #五秒后执行操作函数，优先级为2，并传递参数positional
    s.enter(5,2,print_time,argument=('positional',))
    s.run()
    print("调度器已执行完毕："+datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

if __name__ == '__main__':
    print_some_times()

执行结果:
可以看到5秒及10秒后执行了相应定时的函数，并且也是阻塞的，在调度器执行完执行后才能往下接着运行。

2、每隔几秒执行一次，需要递归定时自调

import time, sched
import datetime

#生成一个sched调度器示例
s = sched.scheduler(time.time, time.sleep)

def perform1(inc):
    print("func1 startTime:", datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))    #指定操作，也就是你要定时执行的操作
    time.sleep(5)
    print("func1 stopTime:", datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    s.enter(inc, 0, perform1, (inc,))    #加入调度事件，使用传入的间隔秒数递归定时自调

def perform2(inc):
    print("func2 startTime:", datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')) #指定操作，也就是你要定时执行的操作
    time.sleep(5)
    print("func2 stopTime:", datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    s.enter(inc, 0, perform2, (inc,))   #加入调度事件，使用传入的间隔秒数递归定时自调

if __name__ == '__main__':
    s.enter(0, 0, perform1, (10,))  # 每隔10秒执行一次perform1,这里一开始时间间隔为0表示马上执行，之后的时间间隔为10
    s.enter(0, 0, perform2, (10,))  # 每隔10秒执行一次perform2
    s.run()
    print("测试是否堵塞")

执行结果：
这里可以看到虽然都设置了每隔10秒执行一次，但func2等func1执行后再执行，说明调度器内的任务是串行执行的。并且调度器没执行完便会一直阻塞主线程，不会往下接着运行。

感觉上面的schedule模块就是一个sched模块的一个调度器，两者的还是挺相似的。

s.run()执行调度器会阻塞当前主线程的执行，可以另开一个线程来执行调度器

t=threading.Thread(target=s.run)
t.start()

执行后可以看到，并未阻塞主线程

也可以用s.cancal(action)来取消sched中的某个action

四、Threading模块中的Timer递归定时自调

优点：非阻塞，多线程
缺点：不易管理多个任务

如果只有一个任务需要每个一段时间执行的话，可以直接用这种方法比较简洁易懂

from threading import Timer
import datetime
# 每隔5秒执行一次任务
def printHello():
    #要执行的任务操作
    print('要执行的动作，TimeNow:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))

    #使用Timer调用自身，递归定时自调
    t = Timer(5, printHello)
    t.start()

if __name__ == "__main__":
    printHello()

    print("测试是否阻塞")

执行结果：
第一次执行了任务后并没有阻塞，可以往下接着执行下面的print操作，说明没有阻塞。

五、定时框架APScheduler 简介

1、介绍
APSScheduler是python的一个定时任务框架，它提供了基于日期date、固定时间间隔interval、以及linux上的crontab类型的定时任务。该框架不仅可以添加、删除定时任务，还可以将任务存储到数据库中、实现任务的持久化。

2、APScheduler有四种组件

• triggers（触发器）：每触发器包含调度逻辑，描述一个任务何时被触发，每一个作业有它自己的触发器，用于决定接下来哪一个作业会运行，按日期或按时间间隔或按 cronjob 表达式三种方式触发。除了他们自己初始化配置外，触发器完全是无状态的。

• job stores（作业存储）：用来存储被调度的作业，默认的作业存储器是简单地把作业任务保存在内存中，其它作业存储器可以将任务作业保存到各种数据库中，支持MongoDB、Redis、SQLAlchemy存储方式。当对作业任务进行持久化存储的时候，作业的数据将被序列化，重新读取作业时在反序列化。

• executors（执行器）：执行器用来执行定时任务，只是将需要执行的任务放在新的线程或者线程池中运行。当作业任务完成时，执行器将会通知调度器。对于执行器，默认情况下选择ThreadPoolExecutor就可以了，但是如果涉及到一下特殊任务如比较消耗CPU的任务则可以选择ProcessPoolExecutor，当然根据根据实际需求可以同时使用两种执行器。

• schedulers（调度器）：调度器是将其它部分联系在一起，一般在应用程序中只有一个调度器，应用开发者不会直接操作触发器、任务存储以及执行器，相反调度器提供了处理的接口。通过调度器完成任务的存储以及执行器的配置操作，如可以添加。修改、移除任务作业。

3、APScheduler提供了七种调度器：

• BlockingScheduler：调度器在当前进程的主线程中运行，也就是会阻塞当前线程。通常在调度器是你唯一要运行的东西时使用。

• BackgroundScheduler: 调度器在后台线程中运行，不会阻塞当前线程。适合于要求任何在程序后台运行的情况，当希望调度器在应用后台执行时使用。

• AsyncIOScheduler：适合于使用asyncio异步框架的情况

• GeventScheduler: 适合于使用gevent框架的情况

• TornadoScheduler: 适合于使用Tornado框架的应用

• TwistedScheduler: 适合使用Twisted框架的应用

• QtScheduler: 适合使用QT的情况

4、APScheduler提供了四种存储方式：

• MemoryJobStore

• sqlalchemy

• mongodb

• redis

5、APScheduler提供了三种任务触发器：

• data：固定日期触发器：任务只运行一次，运行完毕自动清除；若错过指定运行时间，任务不会被创建

• interval：时间间隔触发器

• cron：cron风格的任务触发

六、定时框架APScheduler 示例

1、示例1:

• 调度器：BlockingScheduler调度器，会阻塞主线程
• 任务存储：MemoryJobStore（默认）
• 执行器：ThreadPoolExecutor（默认）
• 触发器：
  （1）固定时间间隔（interval），每隔5秒钟执行一次
  （2）date方式，在2020-06-12 14:58:20只执行一次
  （3）cron方式，每天14:58:20执行

import time
from apscheduler.schedulers.blocking import BlockingScheduler

#定义要执行的操作
def myfunc():
    print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))


if __name__ == '__main__':
    # 该示例代码生成了一个BlockingScheduler调度器，使用了默认的任务存储MemoryJobStore，以及默认的执行器ThreadPoolExecutor，并且最大线程数为10。

    # BlockingScheduler：在进程中运行单个任务，调度器是唯一运行的东西
    scheduler = BlockingScheduler()  # 采用阻塞的方式

    # 采用固定时间间隔（interval）的方式，每隔5秒钟执行一次
    scheduler.add_job(myfunc, 'interval', seconds=5,id="intervaltest")
    #date方式，在2020-06-12 14:58:20只执行一次
    scheduler.add_job(myfunc, 'date', run_date='2020-06-12 14:58:20',id="datetest")
    #cron方式，每天14:58:20执行
    scheduler.add_job(myfunc, 'cron', hour=14, minute=58, second=20, id="crontest")
    scheduler.start()
    print("测试是否阻塞")

执行结果：每五秒执行一次，并且主线程阻塞

2、示例2

• 调度器： BackgroundScheduler调度器，不阻塞主线程
• 任务存储：MemoryJobStore（默认）
• 执行器：ThreadPoolExecutor（默认）
• 触发器：固定时间间隔（interval）的方式，每隔5秒钟执行一次

import time
from apscheduler.schedulers.background import BackgroundScheduler


def myfunc():
    print('job:', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))


if __name__ == '__main__':
    # BackgroundScheduler: 适合于要求任何在程序后台运行的情况，当希望调度器在应用后台执行时使用。
    scheduler = BackgroundScheduler()
    # 采用非阻塞的方式

    # 采用固定时间间隔（interval）的方式，每隔5秒钟执行一次
    scheduler.add_job(myfunc, 'interval', seconds=5)
    # 这是一个独立的线程
    scheduler.start()
    
    print("测试是否阻塞")
    #用来在脚本中保持主线程的运行，否则主线程执行完了调度器也就跟着执行完了。如果是在项目中就可以不用，项目启动时主线程便会一直在。
    while True:

        time.sleep(600)

执行结果：
并没有阻塞主线程，会另开一个线程来执行调度器，可以继续往下执行主线程的其他代码

示例3、

  1   #coding:utf-8
  2   from apscheduler.schedulers.blocking import BlockingScheduler
  3   import datetime
  4   from apscheduler.jobstores.memory import MemoryJobStore
  5   from apscheduler.executors.pool import ThreadPoolExecutor, ProcessPoolExecutor
  6
  7   def my_job(id='my_job'):
  8       print (id,'-->',datetime.datetime.now())
  9   jobstores = {
 10       'default': MemoryJobStore()
 11
 12   }
 13   executors = {
 14       'default': ThreadPoolExecutor(20),
 15       'processpool': ProcessPoolExecutor(10)
 16   }
 17   job_defaults = {
 18       'coalesce': False,
 19       'max_instances': 3
 20   }
 21   scheduler = BlockingScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults)
 22   scheduler.add_job(my_job, args=['job_interval',],id='job_interval',trigger='interval', seconds=5,replace_existing=True)
 23   scheduler.add_job(my_job, args=['job_cron',],id='job_cron',trigger='cron',month='4-8,11-12',hour='7-11', second='*/10',\
 24                     end_date='2018-05-30')
 25   scheduler.add_job(my_job, args=['job_once_now',],id='job_once_now')
 26  scheduler.add_job(my_job, args=['job_date_once',],id='job_date_once',trigger='date',run_date='2018-04-05 07:48:05')
 27   try:
 28       scheduler.start()
 29   except SystemExit:
 30       print('exit')
 31       exit()

示例4、使用数据库作为存储器

  1   #coding:utf-8
  2   from apscheduler.schedulers.blocking import BlockingScheduler
  3   import datetime
  4   from apscheduler.jobstores.memory import MemoryJobStore
  5   from apscheduler.executors.pool import ThreadPoolExecutor, ProcessPoolExecutor
  6   from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
  7   def my_job(id='my_job'):
  8       print (id,'-->',datetime.datetime.now())
  9   jobstores = {
 10       'default': SQLAlchemyJobStore(url='sqlite:///jobs.sqlite')
 11   }
 12   executors = {
 13       'default': ThreadPoolExecutor(20),
 14       'processpool': ProcessPoolExecutor(10)
 15   }
 16   job_defaults = {
 17       'coalesce': False,
 18       'max_instances': 3
 19   }
 20  scheduler = BlockingScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults)
 21  scheduler.add_job(my_job, args=['job_interval',],id='job_interval',trigger='interval', seconds=5,replace_existing=True)
 22   scheduler.add_job(my_job, args=['job_cron',],id='job_cron',trigger='cron',month='4-8,11-12',hour='7-11', second='*/10',\
 23                     end_date='2018-05-30')
 24   scheduler.add_job(my_job, args=['job_once_now',],id='job_once_now')
 25   scheduler.add_job(my_job, args=['job_date_once',],id='job_date_once',trigger='date',run_date='2018-04-05 07:48:05')
 26   try:
 27       scheduler.start()
 28   except SystemExit:
 29       print('exit')
 30       exit()  

七、定时框架APScheduler 调度器scheduler启动关闭和配置

1，启动调度器

scheduler.start()

除了BlockingScheduler以外的调度程序，此调用将立即返回，你可以继续应用程序的初始化过程，例如向调度程序添加作业。

对于BlockingScheduler，只需要在完成任何初始化步骤之后调用start()。

注意：启动调度程序后，不能再更改其设置。

2，关闭调度器
默认情况下，调度程序关闭其作业存储和执行器，并等待所有当前执行的作业完成。

scheduler.shutdown()

如果你不想等，你可以执行。仍然会关闭作业存储和执行器，但不会等待任何正在运行的任务完成。

scheduler.shutdown(wait=False)

3，配置调度器
APScheduler提供了许多不同的方法来配置调度程序。可以使用配置字典，也可以将选项作为关键字参数传入。还可以先实例化调度器，然后添加作业并配置调度器。通过这种方式，可以为任何环境获得最大的灵活性。

（1）默认配置：

如果调度程序在应用程序的后台运行，选择 BackgroundScheduler，并使用默认的 jobstore 和默认的executor，则以下配置即可：

from apscheduler.schedulers.background import BackgroundScheduler
scheduler = BackgroundScheduler()

（2）假如我们想配置更多信息：设置两个执行器、两个作业存储器、调整新作业的默认值，并设置不同的时区。下述三个方法是完全等同的。
配置需求

配置名为“mongo”的MongoDBJobStore作业存储器
配置名为“default”的SQLAlchemyJobStore(使用SQLite)
配置名为“default”的ThreadPoolExecutor，最大线程数为20
配置名为“processpool”的ProcessPoolExecutor，最大进程数为5
UTC作为调度器的时区
coalesce默认情况下关闭
作业的默认最大运行实例限制为3

方法一

  1   from pytz import utc
  2
  3   from apscheduler.schedulers.background import BackgroundScheduler
  4   from apscheduler.jobstores.mongodb import MongoDBJobStore
  5   from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
  6   from apscheduler.executors.pool import ThreadPoolExecutor, ProcessPoolExec
  7
  8
  9   jobstores = {
 10       'mongo': MongoDBJobStore(),
 11       'default': SQLAlchemyJobStore(url='sqlite:///jobs.sqlite')
 12   }
 13   executors = {
 14       'default': ThreadPoolExecutor(20),
 15       'processpool': ProcessPoolExecutor（5）
 16   }
 17   job_defaults = {
 18       'coalesce': False,
 19       'max_instances': 3
 20   }
 21 scheduler = BackgroundScheduler(jobstores=jobstores, executors=executors,    job_defaults=job_defaults, timezone=utc) 

方法二

1   from apscheduler.schedulers.background import BackgroundScheduler
  2   scheduler = BackgroundScheduler({
  3       'apscheduler.jobstores.mongo': {
  4            'type': 'mongodb'
  5       },
  6       'apscheduler.jobstores.default': {
  7           'type': 'sqlalchemy',
  8           'url': 'sqlite:///jobs.sqlite'
  9       },
 10       'apscheduler.executors.default': {
 11           'class': 'apscheduler.executors.pool:ThreadPoolExecutor',
 12           'max_workers': '20'
 13       },
 14       'apscheduler.executors.processpool': {
 15           'type': 'processpool',
 16           'max_workers': '5'
 17       },
 18       'apscheduler.job_defaults.coalesce': 'false',
 19       'apscheduler.job_defaults.max_instances': '3',
 20       'apscheduler.timezone': 'UTC',
 21   })

方法三

  1   from pytz import utc
  2   from apscheduler.schedulers.background import BackgroundScheduler
  3   from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
  4   from apscheduler.executors.pool import ProcessPoolExecutor
  5
  6   jobstores = {
  7       'mongo': {'type': 'mongodb'},
  8       'default': SQLAlchemyJobStore(url='sqlite:///jobs.sqlite')
  9   }
 10   executors = {
 11       'default': {'type': 'threadpool', 'max_workers': 20},
 12       'processpool': ProcessPoolExecutor(max_workers=5)
 13   }
 14   job_defaults = {
 15       'coalesce': False,
 16       'max_instances': 3
 17   }
 18   scheduler = BackgroundScheduler()
 19
 20   # .. do something else here, maybe add jobs etc.
 21

八、定时框架APScheduler 调度器 操作job

1.添加作业
上面是通过add_job()来添加作业，另外还有一种方式是通过scheduled_job()修饰器来修饰函数

import time
from apscheduler.schedulers.blocking import BlockingScheduler
 
sched = BlockingScheduler()
 
@sched.scheduled_job('interval', seconds=5)
def my_job():
    print time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
 
sched.start()

2.移除作业

job = scheduler.add_job(myfunc, 'interval', minutes=2)
job.remove()
#如果有多个任务序列的话可以给每个任务设置ID号，可以根据ID号选择清除对象，且remove放到start前才有效
sched.add_job(myfunc, 'interval', minutes=2, id='my_job_id')
sched.remove_job('my_job_id')

3、暂停和恢复作业
暂停

apsched.job.Job.pause()
apsched.schedulers.base.BaseScheduler.pause_job()

恢复

apsched.job.Job.resume()
apsched.schedulers.base.BaseScheduler.resume_job()

4、获得job列表

scheduler.add_job(job, 'cron', hour=10, minute=54,second=20,id="id1")
scheduler.add_job(job,'interval', seconds=3,id="id2")
print(scheduler.get_jobs())       #获取调度器作业列表 [<Job (id=id1 name=job)>, <Job (id=id2 name=job)>]
print(scheduler.get_jobs()[0].id)       #调度器作业列表第一个作业的获取具体id id1
print(scheduler.get_job(job_id="id1"))   #获取作业job对象 job (trigger: cron[hour='10', minute='54', second='20'], pending)

参考：python实现定时任务
python中schedule模块的使用
花10分钟让你彻底学会Python定时任务框架apscheduler
Python定时任务-APScheduler