scheduler定时器学习使用笔记

最新推荐文章于 2024-02-28 21:37:56 发布

程序员托马斯

最新推荐文章于 2024-02-28 21:37:56 发布

阅读量1.8k

点赞数 2

分类专栏： django python学习文章标签： python

本文链接：https://blog.csdn.net/zhouxuan612/article/details/113996049

版权

python学习同时被 2 个专栏收录

35 篇文章 1 订阅

订阅专栏

django

13 篇文章 0 订阅

订阅专栏

1为什么选择APScheduler

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

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

2 安装

pip install apscheduler

3 四个基本对象

触发器（triggers）：

触发器就是根据你指定的触发方式，比如是按照时间间隔，还是按照 crontab触发，触发条件是什么等。每个任务都有自己的触发器。

任务存储器（job stores）：

任务存储器是可以存储任务的地方，默认情况下任务保存在内存，也可将任务保存在各种数据库中。任务存储进去后，会进行序列化，然后也可以反序列化提取出来，继续执行。

执行器（executors）：

执行器的目的是安排任务到线程池或者进程池中运行的。

4. 调度器（schedulers）：

任务调度器是属于整个调度的总指挥官。他会合理安排作业存储器、执行器、触发器进行工作，并进行添加和删除任务等。调度器通常是只有一个的。开发人员很少直接操作触发器、存储器、执行器等。因为这些都由调度器自动来实现了。

在这里插入图片描述

4 触发器

触发器有三种 interval，crontab，date
1 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()

**注意：1 其中定时器执行的功能参数传参方式
2 start（）只能添加完任务后调用一次否则报错scheduler is running **

2 interval触发器：

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

1、weeks：周。整形。
2、days：一个月中的第几天。整形。
3、hours：小时。整形。
4、minutes：分钟。整形。
5、seconds：秒。整形。
6、start_date：间隔触发的起始时间。
7、end_date：间隔触发的结束时间。
8、jitter：触发的时间误差。

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

# 输出时间
def job():
	with open('D:\\SampleInfoLog\\test.txt','a+') as f:
		f.write("12-")
    	print 'success'
    	print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
scheduler = BlockingScheduler()
scheduler.add_job(job, 'interval',seconds = 05)
scheduler.start()

3 crontab触发器：

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

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

也可以用表达式类型，可以用以下方式：
在这里插入图片描述

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

五、调度器：

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

六、任务存储器：

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

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

七、执行器：

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

1、ThreadPoolExecutor：线程池执行器。
2、ProcessPoolExecutor：进程池执行器。
3、GeventExecutor： Gevent程序执行器。
4、TornadoExecutor： Tornado程序执行器。
5、TwistedExecutor： Twisted程序执行器。
6、AsyncIOExecutor： asyncio程序执行器。

八、定时任务调度配置：

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

1、执行器：

配置 default执行器为 ThreadPoolExecutor，并且设置最多的线程数是20个。
2、存储器：

配置 default的任务存储器为 SQLAlchemyJobStore(使用SQLite)。
3、任务配置：

设置 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')
    }
    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

scheduler.start()

我的代码：

executors = {
    'default': ThreadPoolExecutor(20) # 线程池最大线程数 一个线程可支持多个任务
}

def func():
    now = datetime.now()
    now = now.strftime('%Y-%m-%d')
    start_time = now + " " + '00:00:01'
    end_time = now + " " + '23:59:59'

    announces = Announce.objects.filter(set_time__range=(start_time, end_time)).filter(singnal=1)
    for announce in announces:
        announce.status = 3
    announce.save()


scheduler = BackgroundScheduler(executors=executors, daemon=True) 
scheduler.add_job(func, 'cron', hour=8, minute=0)  # 每天8点进行发送
scheduler.start()

    # 只给此员工创建定时任务
      def func():
               announce.status = 3  # 信息设置成未读状态 1 未发送 2 已读 3 发送但未读
               announce.save()

      # 定时任务
      scheduler.add_job(func, 'date',run_date=datetime(set_time.year, set_time.month, set_time.day, set_time.hour,
                                                    set_time.minute), id=str(announce.id))

程序员托马斯

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
scheduler定时器学习使用笔记

scheduler是轻量级的定时器框架，使用较方便废话不多说直接上代码executors = { 'default': ThreadPoolExecutor(20) # 线程池最大线程数一个线程可支持多个任务}def func(): now = datetime.now() now = now.strftime('%Y-%m-%d') start_time = now + " " + '00:00:01' end_time = now + " " +
复制链接

扫一扫