python 多种定时任务实现方法和举例，包括sleep、Timer、schedule、APScheduler等

╰半橙微兮° 2022-08-28 04:50 119阅读 0赞

python 多种定时任务实现方法和举例，包括sleep、Timer、schedule、APScheduler等，python有很多定时任务框架，包括调用同步方法和异步方法，主要整理一下，除此之外，还有很多其他的实现，例如 celery 等等。

while True: + sleep()  
threading.Timer定时器  
调度模块schedule  
任务框架APScheduler

--------------------

1、while循环中使用sleep  
缺点：不容易控制，而且是个阻塞函数

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

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

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()

3、Threading模块中的Timer  
优点：非阻塞  
缺点：不易管理多个任务

from threading import Timer
    import datetime
    # 每隔两秒执行一次任务
    def printHello():
        print('TimeNow:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
        t = Timer(2, printHello)
        t.start()
    
    if __name__ == "__main__":
        printHello()

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

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

import time, sched
    import datetime
    
    s = sched.scheduler(time.time, time.sleep)
    
    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'))
        s.enter(10,1,print_time)
        s.enter(5,2,print_time,argument=('positional',))
        s.run()
        print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    print_some_times()

执行结果为：

2018-09-20 16:25:03
    Now Time: 2018-09-20 16:25:08 positional
    Now Time: 2018-09-20 16:25:13 default
    2018-09-20 16:25:13
    
    Process finished with exit code 0

按顺序执行任务：

import time, sched
    import datetime
    
    s = sched.scheduler(time.time, time.sleep)
    
    
    def event_fun1():
        print("func1 Time:", datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    
    
    def perform1(inc):
        s.enter(inc, 0, perform1, (inc,))
        event_fun1()
    
    
    def event_fun2():
        print("func2 Time:", datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    
    
    def perform2(inc):
        s.enter(inc, 0, perform2, (inc,))
        event_fun2()
    
    
    def mymain(func, inc=2):
        if func == "1":
            s.enter(0, 0, perform1, (10,))# 每隔10秒执行一次perform1
        if func == "2":
            s.enter(0, 0, perform2, (20,))# 每隔20秒执行一次perform2
    if __name__ == '__main__':
        mymain('1')
        mymain('2')
        s.run()

执行结果为：

func1 Time: 2018-09-20 16:30:28
    func2 Time: 2018-09-20 16:30:28
    func1 Time: 2018-09-20 16:30:38
    func2 Time: 2018-09-20 16:30:48
    func1 Time: 2018-09-20 16:30:48
    func1 Time: 2018-09-20 16:30:58
    func2 Time: 2018-09-20 16:31:08
    func1 Time: 2018-09-20 16:31:08
    func1 Time: 2018-09-20 16:31:18
    func2 Time: 2018-09-20 16:31:28
    func1 Time: 2018-09-20 16:31:28
    func1 Time: 2018-09-20 16:31:38

s.run()会阻塞当前线程的执行  
可以用

t=threading.Thread(target=s.run)  
t.start()  
也可以用s.cancal(action)来取消sched中的某个action

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

APScheduler是一个 Python 定时任务框架，使用起来十分方便。提供了基于日期、固定时间间隔以及 crontab 类型的任务，并且可以持久化任务、并以 daemon 方式运行应用。

使用 APScheduler 需要安装

pip install apscheduler

APScheduler有四种组件：  
triggers（触发器）：触发器包含调度逻辑，每一个作业有它自己的触发器，用于决定接下来哪一个作业会运行，除了他们自己初始化配置外，触发器完全是无状态的。

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

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

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

APScheduler提供了七种调度器：  
BlockingScheduler：适合于只在进程中运行单个任务的情况，通常在调度器是你唯一要运行的东西时使用。

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

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

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

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

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

QtScheduler: 适合使用QT的情况

APScheduler提供了四种存储方式：  
MemoryJobStore  
sqlalchemy  
mongodb  
redis  
APScheduler提供了三种任务触发器：  
data：固定日期触发器：任务只运行一次，运行完毕自动清除；若错过指定运行时间，任务不会被创建

interval：时间间隔触发器

cron：cron风格的任务触发

示例1、
    import time
    from apscheduler.schedulers.blocking import BlockingScheduler
    
    def job():
        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(job, 'interval', seconds=5)
        
        scheduler.start()
    
    示例2、
    import time
    from apscheduler.schedulers.blocking import BlockingScheduler
    
    def job():
        print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
        
    if __name__ == '__main__':
        # BlockingScheduler：在进程中运行单个任务，调度器是唯一运行的东西
        scheduler = BlockingScheduler()
        # 采用阻塞的方式
        
        # 采用date的方式，在特定时间只执行一次
        scheduler.add_job(job, 'date', run_date='2018-09-21 15:30:00')
    
        scheduler.start() 
    
    示例3、
    import time
    from apscheduler.schedulers.background import BackgroundScheduler
    
    def job():
        print('job:', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
    
    if __name__ == '__main__':
        # BackgroundScheduler: 适合于要求任何在程序后台运行的情况，当希望调度器在应用后台执行时使用。
        scheduler = BackgroundScheduler()
        # 采用非阻塞的方式
    
        # 采用固定时间间隔（interval）的方式，每隔3秒钟执行一次
        scheduler.add_job(job, 'interval', seconds=3)
        # 这是一个独立的线程
        scheduler.start()
        
        # 其他任务是独立的线程
        while True:
            print('main-start:', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
            time.sleep(2)
            print('main-end:', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
    运行结果为：
    
    main-start: 2018-09-21 15:54:28
    main-end: 2018-09-21 15:54:30
    main-start: 2018-09-21 15:54:30
    job: 2018-09-21 15:54:31
    main-end: 2018-09-21 15:54:32
    main-start: 2018-09-21 15:54:32
    main-end: 2018-09-21 15:54:34
    main-start: 2018-09-21 15:54:34
    job: 2018-09-21 15:54:34
    main-end: 2018-09-21 15:54:36
    main-start: 2018-09-21 15:54:36
    
    示例4、
    import time
    from apscheduler.schedulers.background import BackgroundScheduler
    
    def job():
        print('job:', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
    
    if __name__ == '__main__':
        # BackgroundScheduler: 适合于要求任何在程序后台运行的情况，当希望调度器在应用后台执行时使用。
        scheduler = BackgroundScheduler()
        # 采用非阻塞的方式
    
        # 采用date的方式，在特定时间里执行一次
        scheduler.add_job(job, 'date', run_date='2018-09-21 15:53:00')
        # 这是一个独立的线程
        scheduler.start()
    
        # 其他任务是独立的线程
        while True:
            print('main-start:', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
            time.sleep(2)
            print('main-end:', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
    运行结果为：
    
    main-start: 2018-09-21 15:52:57
    main-end: 2018-09-21 15:52:59
    main-start: 2018-09-21 15:52:59
    job: 2018-09-21 15:53:00
    main-end: 2018-09-21 15:53:01
    
    示例5、
    import time
    from apscheduler.schedulers.background import BackgroundScheduler
    
    
    def job():
        print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
    
    
    if __name__ == '__main__':
        # BackgroundScheduler: 适合于要求任何在程序后台运行的情况，当希望调度器在应用后台执行时使用
        scheduler = BackgroundScheduler()
        # 采用非阻塞的方式
    
        # 采用corn的方式
        scheduler.add_job(job, 'cron', day_of_week='fri', second='*/5')
        '''
        year (int|str) – 4-digit year
        month (int|str) – month (1-12)
        day (int|str) – day of the (1-31)
        week (int|str) – ISO week (1-53)
        day_of_week (int|str) – number or name of weekday (0-6 or mon,tue,wed,thu,fri,sat,sun)
        hour (int|str) – hour (0-23)
        minute (int|str) – minute (0-59)
        econd (int|str) – second (0-59)
                
        start_date (datetime|str) – earliest possible date/time to trigger on (inclusive)
        end_date (datetime|str) – latest possible date/time to trigger on (inclusive)
        timezone (datetime.tzinfo|str) – time zone to use for the date/time calculations (defaults to scheduler timezone)
            
        *    any    Fire on every value
        */a    any    Fire every a values, starting from the minimum
        a-b    any    Fire on any value within the a-b range (a must be smaller than b)
        a-b/c    any    Fire every c values within the a-b range
        xth y    day    Fire on the x -th occurrence of weekday y within the month
        last x    day    Fire on the last occurrence of weekday x within the month
        last    day    Fire on the last day within the month
        x,y,z    any    Fire on any matching expression; can combine any number of any of the above expressions
        '''
        scheduler.start()
        
        # 其他任务是独立的线程
        while True:
            print('main-start:', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
            time.sleep(2)
            print('main-end:', time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
    运行结果：
    
    main-start: 2018-09-21 16:02:55
    main-end: 2018-09-21 16:02:57
    main-start: 2018-09-21 16:02:57
    main-end: 2018-09-21 16:02:59
    main-start: 2018-09-21 16:02:59
    2018-09-21 16:03:00
    main-end: 2018-09-21 16:03:01
    main-start: 2018-09-21 16:03:01
    main-end: 2018-09-21 16:03:03
    main-start: 2018-09-21 16:03:03
    2018-09-21 16:03:05
    main-end: 2018-09-21 16:03:05
    main-start: 2018-09-21 16:03:05
    main-end: 2018-09-21 16:03:07
    main-start: 2018-09-21 16:03:07
    main-end: 2018-09-21 16:03:09
    main-start: 2018-09-21 16:03:09
    2018-09-21 16:03:10
    
    示例6、
    import time
    from apscheduler.schedulers.background import BackgroundScheduler
    
    
    def job():
        print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
    
    
    if __name__ == '__main__':
        # BackgroundScheduler: 适合于要求任何在程序后台运行的情况，当希望调度器在应用后台执行时使用
        scheduler = BackgroundScheduler()
        # 采用阻塞的方式
    
        # 采用corn的方式
        scheduler.add_job(job, 'cron', day_of_week='fri', second='*/5')
        '''
        year (int|str) – 4-digit year
        month (int|str) – month (1-12)
        day (int|str) – day of the (1-31)
        week (int|str) – ISO week (1-53)
        day_of_week (int|str) – number or name of weekday (0-6 or mon,tue,wed,thu,fri,sat,sun)
        hour (int|str) – hour (0-23)
        minute (int|str) – minute (0-59)
        econd (int|str) – second (0-59)
                
        start_date (datetime|str) – earliest possible date/time to trigger on (inclusive)
        end_date (datetime|str) – latest possible date/time to trigger on (inclusive)
        timezone (datetime.tzinfo|str) – time zone to use for the date/time calculations (defaults to scheduler timezone)
            
        *    any    Fire on every value
        */a    any    Fire every a values, starting from the minimum
        a-b    any    Fire on any value within the a-b range (a must be smaller than b)
        a-b/c    any    Fire every c values within the a-b range
        xth y    day    Fire on the x -th occurrence of weekday y within the month
        last x    day    Fire on the last occurrence of weekday x within the month
        last    day    Fire on the last day within the month
        x,y,z    any    Fire on any matching expression; can combine any number of any of the above expressions
        '''
    
        scheduler.start()
    
    示例7、
    import time
    from pymongo import MongoClient
    from apscheduler.schedulers.blocking import BlockingScheduler
    from apscheduler.jobstores.mongodb import MongoDBJobStore
    
    def job():
        print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
    if __name__ == '__main__':
        # mongodb存储job
        scheduler = BlockingScheduler()
        client = MongoClient(host='127.0.0.1', port=27017)
        store = MongoDBJobStore(collection='job', database='test', client=client)
        scheduler.add_jobstore(store)
        scheduler.add_job(job, 'interval', second=5)
        scheduler.start()

APScheduler提供了许多不同的方式来配置调度器，你可以使用一个配置字典或者作为参数关键字的方式传入。你也可以先创建调度器，再配置和添加作业，这样你可以在不同的环境中得到更大的灵活性。

下面来看一个简单的 BlockingScheduler 例子：

from apscheduler.schedulers.blocking import BlockingScheduler
    from datetime import datetime
    
    def job():
        print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    # 定义BlockingScheduler
    sched = BlockingScheduler()
    sched.add_job(job, 'interval', seconds=5)
    sched.start()

上述代码创建了一个 BlockingScheduler，并使用默认内存存储和默认执行器。(默认选项分别是 MemoryJobStore 和 ThreadPoolExecutor，其中线程池的最大线程数为10)。配置完成后使用 start() 方法来启动。

如果想要显式设置 job store(使用mongo存储)和 executor 可以这样写：

from datetime import datetime
    from pymongo import MongoClient
    from apscheduler.schedulers.blocking import BlockingScheduler
    from apscheduler.jobstores.memory import MemoryJobStore
    from apscheduler.jobstores.mongodb import MongoDBJobStore
    from apscheduler.executors.pool import ThreadPoolExecutor, ProcessPoolExecutor
    # MongoDB 参数
    host = '127.0.0.1'
    port = 27017
    client = MongoClient(host, port)
    # 输出时间
    def job():
        print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    # 存储方式
    jobstores = {
        
        'mongo': MongoDBJobStore(collection='job', database='test', client=client),
        'default': MemoryJobStore()
    }
    executors = {
        
        'default': ThreadPoolExecutor(10),
        'processpool': ProcessPoolExecutor(3)
    }
    job_defaults = {
        
        'coalesce': False,
        'max_instances': 3
    }
    scheduler = BlockingScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults)
    scheduler.add_job(job, 'interval', seconds=5, jobstore='mongo')
    scheduler.start()

trigger 规则  
date  
最基本的一种调度，作业只会执行一次。它的参数如下：

run\_date (datetime|str) – the date/time to run the job at  
timezone (datetime.tzinfo|str) – time zone for run\_date if it doesn’t have one already

from datetime import date
    from apscheduler.schedulers.blocking import BlockingScheduler
    sched = BlockingScheduler()
    def my_job(text):
        print(text)
    # The job will be executed on November 6th, 2009
    sched.add_job(my_job, 'date', run_date=date(2009, 11, 6), args=['text'])
    sched.add_job(my_job, 'date', run_date=datetime(2009, 11, 6, 16, 30, 5), args=['text'])
    sched.add_job(my_job, 'date', run_date='2009-11-06 16:30:05', args=['text'])
    # The 'date' trigger and datetime.now() as run_date are implicit
    sched.add_job(my_job, args=['text'])
    sched.start()

cron  
year (int|str) – 4-digit year  
month (int|str) – month (1-12)  
day (int|str) – day of the (1-31)  
week (int|str) – ISO week (1-53)  
day\_of\_week (int|str) – number or name of weekday (0-6 or mon,tue,wed,thu,fri,sat,sun)  
hour (int|str) – hour (0-23)  
minute (int|str) – minute (0-59)  
second (int|str) – second (0-59)  
start\_date (datetime|str) – earliest possible date/time to trigger on (inclusive)  
end\_date (datetime|str) – latest possible date/time to trigger on (inclusive)  
timezone (datetime.tzinfo|str) – time zone to use for the date/time calculations (defaults to scheduler timezone)

from apscheduler.schedulers.blocking import BlockingScheduler
    
    def job_function():
        print("Hello World")
    # BlockingScheduler
    sched = BlockingScheduler()
    # Schedules job_function to be run on the third Friday
    # of June, July, August, November and December at 00:00, 01:00, 02:00 and 03:00
    sched.add_job(job_function, 'cron', month='6-8,11-12', day='3rd fri', hour='0-3')
    # Runs from Monday to Friday at 5:30 (am) until 2014-05-30 00:00:00
    sched.add_job(job_function, 'cron', day_of_week='mon-fri', hour=5, minute=30, end_date='2014-05-30')
    sched.start()

interval

weeks (int) – number of weeks to wait  
days (int) – number of days to wait  
hours (int) – number of hours to wait  
minutes (int) – number of minutes to wait  
seconds (int) – number of seconds to wait  
start\_date (datetime|str) – starting point for the interval calculation  
end\_date (datetime|str) – latest possible date/time to trigger on  
timezone (datetime.tzinfo|str) – time zone to use for the date/time calculations

from datetime import datetime
    from apscheduler.schedulers.blocking import BlockingScheduler
    
    def job_function():
        print("Hello World")
    # BlockingScheduler
    sched = BlockingScheduler()
    # Schedule job_function to be called every two hours
    sched.add_job(job_function, 'interval', hours=2)
    # The same as before, but starts on 2010-10-10 at 9:30 and stops on 2014-06-15 at 11:00
    sched.add_job(job_function, 'interval', hours=2, start_date='2010-10-10 09:30:00', end_date='2014-06-15 11:00:00')
    sched.start()

--------------------

根据项目需求需要实现三个定时任务：

1>定时更新微信token，需要2小时更新一次；  
2>商品定时上线；  
3>定时检测后台服务是否存活；

Python实现定点与定时任务方式比较多，每个方式都有自己应用场景；下面来快速介绍Python中常用的定时任务实现方式：

1>循环+sleep；  
2>线程模块中Timer类；  
3>schedule模块；  
4>定时框架：APScheduler

在开始之前先设定一个任务（这样不用依赖外部环境）：  
1：定时或者定点监测CPU与内存使用率；  
2：将时间，CPU，内存使用情况保存到日志文件；

先来实现系统监测功能：  
准备工作：安装psutil：pip install psutil  
功能实现

#psutil:获取系统信息模块，可以获取CPU，内存，磁盘等的使用情况
    import psutil
    import time
    import datetime
    #logfile：监测信息写入文件
    def MonitorSystem(logfile = None):
        #获取cpu使用情况
        cpuper = psutil.cpu_percent()
        #获取内存使用情况：系统内存大小，使用内存，有效内存，内存使用率
        mem = psutil.virtual_memory()
        #内存使用率
        memper = mem.percent
        #获取当前时间
        now = datetime.datetime.now()
        ts = now.strftime('%Y-%m-%d %H:%M:%S')
        line = f'{ts} cpu:{cpuper}%, mem:{memper}%'
        print(line)
        if logfile:
            logfile.write(line)

代码运行结果：

2019-03-21 14:23:41 cpu:0.6%, mem:77.2%

接下来我们要实现定时监测，比如3s监测一下系统资源使用情况。

最简单使用方式：sleep  
这种方式最简单，直接使用while+sleep就可以实现：

def loopMonitor():
        while True:
            MonitorSystem()
            #2s检查一次
            time.sleep(3)
    loopMonitor()

输出结果：

2019-03-21 14:28:42 cpu:1.5%, mem:77.6%
    2019-03-21 14:28:45 cpu:1.6%, mem:77.6%
    2019-03-21 14:28:48 cpu:1.4%, mem:77.6%
    2019-03-21 14:28:51 cpu:1.4%, mem:77.6%
    2019-03-21 14:28:54 cpu:1.3%, mem:77.6%

这种方式存在问题：只能处理单个定时任务。  
又来了新任务：需要每秒监测网络收发字节，代码实现如下：

def MonitorNetWork(logfile = None):
        #获取网络收信息
        netinfo = psutil.net_io_counters()
        #获取当前时间
        now = datetime.datetime.now()
        ts = now.strftime('%Y-%m-%d %H:%M:%S')
        line = f'{ts} bytessent={netinfo.bytes_sent}, bytesrecv={netinfo.bytes_recv}'
        print(line)
        if logfile:
            logfile.write(line)
    MonitorNetWork()

代码执行结果：

2019-03-21 14:47:21 bytessent=169752183, bytesrecv=1107900973

如果我们同时在while循环中监测两个任务会有等待问题，不能每秒监测网络情况。

Timer实现方式  
timer最基本理解就是定时器，我们可以启动多个定时任务，这些定时器任务是异步执行，所以不存在等待顺序执行问题。  
先来看Timer的基本使用：

主要方法：

Timer方法 说明  
Timer(interval, function, args=None, kwargs=None) 创建定时器  
cancel() 取消定时器  
start() 使用线程方式执行  
join(self, timeout=None) 等待线程执行结束

定时器只能执行一次，如果需要重复执行，需要重新添加任务；

我们先来看基本使用：

from threading import Timer
    #记录当前时间
    print(datetime.datetime.now())
    #3S执行一次
    sTimer = Timer(3, MonitorSystem)
    #1S执行一次
    nTimer = Timer(1, MonitorNetWork)
    #使用线程方式执行
    sTimer.start()
    nTimer.start()
    #等待结束
    sTimer.join()
    nTimer.join()
    #记录结束时间
    print(datetime.datetime.now())

输出结果：

2019-03-21 15:13:36.739798
    2019-03-21 15:13:37 bytessent=171337324, bytesrecv=1109002349
    2019-03-21 15:13:39 cpu:1.4%, mem:93.2%
    2019-03-21 15:13:39.745187

可以看到，花费时间为3S，但是我们想要做的是每秒监控网络状态；如何处理。  
Timer只能执行一次，所以执行完成之后需要再次添加任务，我们对代码进行修改：

from threading import Timer
    import psutil
    import time
    import datetime
    def MonitorSystem(logfile = None):
        cpuper = psutil.cpu_percent()
        mem = psutil.virtual_memory()
        memper = mem.percent
        now = datetime.datetime.now()
        ts = now.strftime('%Y-%m-%d %H:%M:%S')
        line = f'{ts} cpu:{cpuper}%, mem:{memper}%'
        print(line)
        if logfile:
            logfile.write(line)
        #启动定时器任务，每三秒执行一次
        Timer(3, MonitorSystem).start()
    
    def MonitorNetWork(logfile = None):
        netinfo = psutil.net_io_counters()
        now = datetime.datetime.now()
        ts = now.strftime('%Y-%m-%d %H:%M:%S')
        line = f'{ts} bytessent={netinfo.bytes_sent}, bytesrecv={netinfo.bytes_recv}'
        print(line)
        if logfile:
            logfile.write(line)
        #启动定时器任务，每秒执行一次
        Timer(1, MonitorNetWork).start()
    MonitorSystem()
    MonitorNetWork()

执行结果：

2019-03-21 15:18:21 cpu:1.5%, mem:93.2%
    2019-03-21 15:18:21 bytessent=171376522, bytesrecv=1109124678
    2019-03-21 15:18:22 bytessent=171382215, bytesrecv=1109128294
    2019-03-21 15:18:23 bytessent=171384278, bytesrecv=1109129702
    2019-03-21 15:18:24 cpu:1.9%, mem:93.2%
    2019-03-21 15:18:24 bytessent=171386341, bytesrecv=1109131110
    2019-03-21 15:18:25 bytessent=171388527, bytesrecv=1109132600
    2019-03-21 15:18:26 bytessent=171390590, bytesrecv=1109134008

从时间中可以看到，这两个任务可以同时进行不存在等待问题。  
Timer的实质是使用线程方式去执行任务，每次执行完后会销毁，所以不必担心资源问题。

调度模块：schedule  
schedule是一个第三方轻量级的任务调度模块，可以按照秒，分，小时，日期或者自定义事件执行时间；  
安装方式：

pip install schedule

我们来看一个例子：

import datetime
    import schedule
    import time
    def func():
        now = datetime.datetime.now()
        ts = now.strftime('%Y-%m-%d %H:%M:%S')
        print('do func  time :',ts)
    def func2():
        now = datetime.datetime.now()
        ts = now.strftime('%Y-%m-%d %H:%M:%S')
        print('do func2 time：',ts)
    def tasklist():
        #清空任务
        schedule.clear()
        #创建一个按秒间隔执行任务
        schedule.every(1).seconds.do(func)
        #创建一个按2秒间隔执行任务
        schedule.every(2).seconds.do(func2)
        #执行10S
        for i in range(10):
            schedule.run_pending()
            time.sleep(1)
    tasklist()

执行结果：

do func  time : 2019-03-22 08:51:38
    do func2 time： 2019-03-22 08:51:39
    do func  time : 2019-03-22 08:51:39
    do func  time : 2019-03-22 08:51:40
    do func2 time： 2019-03-22 08:51:41
    do func  time : 2019-03-22 08:51:41
    do func  time : 2019-03-22 08:51:42
    do func2 time： 2019-03-22 08:51:43
    do func  time : 2019-03-22 08:51:43
    do func  time : 2019-03-22 08:51:44
    do func2 time： 2019-03-22 08:51:45
    do func  time : 2019-03-22 08:51:45
    do func  time : 2019-03-22 08:51:46

执行过程分析：

> 1>因为在jupyter下执行，所以先将schedule任务清空；  
> 2>按时间间在schedule中隔添加任务；  
> 3>这里按照秒间隔添加func，按照两秒间隔添加func2;  
> 4>schedule添加任务后，需要查询任务并执行任务；  
> 5>为了防止占用资源，每秒查询到点任务，然后顺序执行；

第5个顺序执行怎么理解，我们修改func函数，里面添加time.sleep(2)  
然后只执行func工作，输出结果：

do func  time : 2019-03-22 09:00:59
    do func  time : 2019-03-22 09:01:02
    do func  time : 2019-03-22 09:01:05

可以看到时间间隔为3S，为什么不是1S？  
因为这个按照顺序执行，func休眠2S，循环任务查询休眠1S，所以会存在这个问题。  
在我们使用这种方式执行任务需要注意这种阻塞现象。  
我们看下schedule模块常用使用方法：

#schedule.every(1)创建Job, seconds.do(func)按秒间隔查询并执行
    schedule.every(1).seconds.do(func)
    #添加任务按分执行
    schedule.every(1).minutes.do(func)
    #添加任务按天执行
    schedule.every(1).days.do(func)
    #添加任务按周执行
    schedule.every().weeks.do(func)
    #添加任务每周1执行，执行时间为下周一这一时刻时间
    schedule.every().monday.do(func)
    #每周1，1点15开始执行
    schedule.every().monday.at("12:00").do(job)

这种方式局限性：如果工作任务回非常耗时就会影响其他任务执行。我们可以考虑使用并发机制配置这个模块使用。

任务框架APScheduler  
APScheduler是Python的一个定时任务框架，用于执行周期或者定时任务，  
可以基于日期、时间间隔，及类似于Linux上的定时任务crontab类型的定时任务；  
该该框架不仅可以添加、删除定时任务，还可以将任务存储到数据库中，实现任务的持久化，使用起来非常方便。  
安装方式：pip install apscheduler  
apscheduler组件及简单说明：

1>triggers（触发器）：触发器包含调度逻辑，每一个作业有它自己的触发器  
2>job stores（作业存储）:用来存储被调度的作业，默认的作业存储器是简单地把作业任务保存在内存中,支持存储到MongoDB，Redis数据库中  
3> executors（执行器）：执行器用来执行定时任务，只是将需要执行的任务放在新的线程或者线程池中运行  
4>schedulers（调度器）：调度器是将其它部分联系在一起,对使用者提供接口，进行任务添加，设置，删除。

来看一个简单例子：

import time
    from apscheduler.schedulers.blocking import BlockingScheduler
    def func():
        now = datetime.datetime.now()
        ts = now.strftime('%Y-%m-%d %H:%M:%S')
        print('do func  time :',ts)
        
    def func2():
        #耗时2S
        now = datetime.datetime.now()
        ts = now.strftime('%Y-%m-%d %H:%M:%S')
        print('do func2 time：',ts)
        time.sleep(2)
        
    def dojob():
        #创建调度器：BlockingScheduler
        scheduler = BlockingScheduler()
        #添加任务,时间间隔2S
        scheduler.add_job(func, 'interval', seconds=2, id='test_job1')
        #添加任务,时间间隔5S
        scheduler.add_job(func2, 'interval', seconds=3, id='test_job2')
        scheduler.start()
    dojob()

输出结果：

do func  time : 2019-03-22 10:32:20
    do func2 time： 2019-03-22 10:32:21
    do func  time : 2019-03-22 10:32:22
    do func  time : 2019-03-22 10:32:24
    do func2 time： 2019-03-22 10:32:24
    do func  time : 2019-03-22 10:32:26

输出结果中可以看到：任务就算是有延时，也不会影响其他任务执行。  
APScheduler框架提供丰富接口去实现定时任务，可以去参考官方文档去查看使用方式。

最后选择：  
简单总结上面四种定时定点任务实现：  
1：循环+sleep方式适合简答测试，  
2：timer可以实现定时任务，但是对定点任务来说，需要检查当前时间点；  
3：schedule可以定点定时执行，但是需要在循环中检测任务，而且存在阻塞；  
4：APScheduler框架更加强大，可以直接在里面添加定点与定时任务；  
综合考虑，决定使用APScheduler框架，实现简单，只需要直接创建任务，并将添加到调度器中即可。