Python关于定时任务

最新推荐文章于 2024-04-22 10:23:02 发布
最新推荐文章于 2024-04-22 10:23:02 发布
阅读量618 收藏 7
点赞数 1
分类专栏： 笔记 文章标签： python 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43835542/article/details/105773885
版权

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

1.循环+sleep；

2.线程模块中Timer类；

3.schedule模块；

4.定时框架：APScheduler

文章目录

一、循环 + sleep

优点：

适合简单的测试

缺点：

只能处理单个定时任务，不容易控制，而且是个阻塞函数，time.sleep()是睡眠线程。
当前线程调用 sleep() 函数进入阻塞状态后，在其睡眠时间段内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于 sleep() 中的线程也不会执行，因此 sleep() 函数常用来暂停程序的运行。

代码：

测试一：只能处理单个定时任务。

import time

def fun1():
    print('fun1:',time.ctime())

def run():
    while True:
        fun1()
        time.sleep(3)   # 每隔3S执行一次
run()

# 结果：
fun1: Sun Apr 26 17:57:02 2020
fun1: Sun Apr 26 17:57:05 2020
fun1: Sun Apr 26 17:57:08 2020

测试二：假如我又加进来一个函数，我想每秒都执行

import time

def fun1():
    print('fun1:',time.ctime())

def fun2():
    print('fun2:',time.ctime())

def run():
    while True:
        fun1()
        time.sleep(3)   # 每3S执行一次
        fun2()          # 每1s执行一次

run()

# 结果
fun1: Sun Apr 26 18:04:03 2020
fun2: Sun Apr 26 18:04:06 2020	# 等fun1() 执行完以后才可以执行
fun1: Sun Apr 26 18:04:06 2020
fun2: Sun Apr 26 18:04:09 2020
fun1: Sun Apr 26 18:04:09 2020
fun2: Sun Apr 26 18:04:12 2020
fun1: Sun Apr 26 18:04:12 2020
fun2: Sun Apr 26 18:04:15 2020
fun1: Sun Apr 26 18:04:15 2020

二、线程模块中Timer类

timer最基本理解就是定时器，我们可以启动多个定时任务，这些定时器任务是异步执行，所以不存在等待顺序执行问题。
定时器只能执行一次，如果需要重复执行，需要重新添加任务；

Time 模块理解

优点：

非阻塞,Timer的实质是使用线程方式去执行任务，每次执行完后会销毁，所以不必担心资源问题。

缺点：

不易管理多个任务

代码：

测试一： Timer只能执行一次

import datetime
import time
from threading import Timer

def fun1():
    print('fun1:',time.ctime())

def fun2():
    print('fun2:',time.ctime())

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

# 结果
2020-04-26 18:42:12.933858
fun2: Sun Apr 26 18:42:13 2020
fun1: Sun Apr 26 18:42:15 2020
2020-04-26 18:42:15.934419

测试二： Timer只能执行一次，所以执行完成之后需要再次添加任务，我们对代码进行修改：

import datetime
import time
from threading import Timer

def fun1():
    print('fun1:',time.ctime())
    # 启动定时器任务，每3秒执行一次
    Timer(3, fun1).start()

def fun2():
    print('fun2:',time.ctime())
    # 启动定时器任务，每1秒执行一次
    Timer(1, fun2).start()

fun1()
fun2()

# 结果
fun1: Sun Apr 26 18:54:28 2020
fun2: Sun Apr 26 18:54:28 2020
fun2: Sun Apr 26 18:54:29 2020
fun2: Sun Apr 26 18:54:30 2020
fun1: Sun Apr 26 18:54:31 2020
fun2: Sun Apr 26 18:54:31 2020
fun2: Sun Apr 26 18:54:32 2020
fun2: Sun Apr 26 18:54:33 2020
......
无限循环下去

从时间中可以看到，这两个任务可以同时进行不存在等待问题

三、schedule模块

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

安装方式：
pip install schedule

优点：

可以管理和调度多个任务,可以进行控制

缺点：

阻塞式函数

代码：

普通版本，简单介绍：

import schedule
import time

def job():
    print("I'm working...")

schedule.every(10).seconds.do(job)	    # 每隔十秒钟执行一次任务
schedule.every(10).minutes.do(job)	    # 每隔十分钟执行一次任务
schedule.every(1).hour.do(job)	        # 每隔一小时执行一次任务
schedule.every().day.at("10:30").do(job)# 每天的10:30执行一次任务
schedule.every(5).to(10).days.do(job)	# 每隔5到10天执行一次任务
schedule.every().monday.do(job)         # 每周一的这个时候执行一次任务
schedule.every().wednesday.at("13:15").do(job)  # 每周三13:15执行一次任务

while True:
    schedule.run_pending()  # 运行所有可以运行的任务
    time.sleep(1)

普通版本调用，阻塞：

import schedule
import datetime
import time
import threading

def job():
    print("I'm working... in job1  start  {}".format(datetime.datetime.now()))
    time.sleep(10)
    print("I'm working... in job1  end  {}".format(datetime.datetime.now()))

def job2():
    print("I'm working... in job2        {}".format(datetime.datetime.now()))

schedule.every(3).seconds.do(job)
schedule.every(3).seconds.do(job2)

while True:
    schedule.run_pending()
    time.sleep(1)
 
# 结果 注意看 时间
I'm working... in job1  start  2020-04-29 17:26:20.229107
I'm working... in job1  end  2020-04-29 17:26:30.229383
I'm working... in job2        2020-04-29 17:26:30.229383
I'm working... in job1  start  2020-04-29 17:26:33.230687
I'm working... in job1  end  2020-04-29 17:26:43.231527
I'm working... in job2        2020-04-29 17:26:43.231527
I'm working... in job1  start  2020-04-29 17:26:46.232750
I'm working... in job1  end  2020-04-29 17:26:56.233455
I'm working... in job2        2020-04-29 17:26:56.233455
I'm working... in job1  start  2020-04-29 17:26:59.234296
I'm working... in job1  end  2020-04-29 17:27:09.235169
I'm working... in job2        2020-04-29 17:27:09.235169

改为线程版本，非阻塞：

import schedule
import datetime
import time
import threading

def job():
    print("I'm working... in job1  start  {}".format(datetime.datetime.now()))
    time.sleep(10)
    print("I'm working... in job1  end  {}".format(datetime.datetime.now()))

def job2():
    print("I'm working... in job2        {}".format(datetime.datetime.now()))


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

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

while True:
    schedule.run_pending()
    time.sleep(1)
 
# 结果 注意看  时间 和 statr 和 end
I'm working... in job1  start  2020-04-29 17:28:24.361645
I'm working... in job2        2020-04-29 17:28:24.361645
I'm working... in job1  start  2020-04-29 17:28:27.363522
I'm working... in job2        2020-04-29 17:28:27.363522
I'm working... in job1  start  2020-04-29 17:28:30.364084
I'm working... in job2        2020-04-29 17:28:30.364974
I'm working... in job1  start  2020-04-29 17:28:33.365655
I'm working... in job2        2020-04-29 17:28:33.366683
I'm working... in job1  end  2020-04-29 17:28:34.362784
I'm working... in job1  start  2020-04-29 17:28:36.367951
I'm working... in job2        2020-04-29 17:28:36.368827
I'm working... in job1  end  2020-04-29 17:28:37.365054
I'm working... in job1  start  2020-04-29 17:28:39.370776
I'm working... in job2        2020-04-29 17:28:39.371645
I'm working... in job1  end  2020-04-29 17:28:40.365915

最近有人问我while True之类的是什么意思，很简单，如果你去掉while True这个死循环的话，schedule.run_pending()是没有办法持续运行的，那么schedule.run_pending()是个什么东西呢——

schedule其实就只是个定时器。在while True死循环中，schedule.run_pending()是保持schedule一直运行，去查询上面那一堆的任务，在任务中，就可以设置不同的时间去运行。跟linux中设置crontab定时任务是类似的。

所以，schedule有一定的局限性，所以只能用来执行一些小型的定时任务，它的局限性在哪呢——

1.需要定时运行的函数job不应当是死循环类型的，也就是说，这个线程应该有一个执行完毕的出口。一是因为线程万一僵死，会是非常棘手的问题；二是下一次定时任务还会开启一个新的线程，执行次数多了就会演变成灾难。

2.如果schedule的时间间隔设置得比job执行的时间短，一样会线程堆积形成灾难，也就是说，我job的执行时间是1个小时，但是我定时任务设置的是5分钟一次，那就会一直堆积线程。

四、定时框架：APScheduler

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

安装方式：pip install apscheduler

apscheduler组件及简单说明：

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

interval 触发器
参数 说明
weeks (int) 间隔几周
days (int) 间隔几天
hours (int) 间隔几小时
minutes (int) 间隔几分钟
seconds (int) 间隔多少秒
start_date (datetime 或 str) 开始日期
end_date (datetime 或 str) 结束日期
timezone (datetime.tzinfo 或str) 时区

cron 触发器:
参数 说明
year (int 或 str) 年，4位数字
month (int 或 str) 月 (范围1-12)
day (int 或 str) 日 (范围1-31
week (int 或 str) 周 (范围1-53)
day_of_week (int 或 str) 周内第几天或者星期几 (范围0-6 或者 mon,tue,wed,thu,fri,sat,sun)
hour (int 或 str) 时 (范围0-23)
minute (int 或 str) 分 (范围0-59)
second (int 或 str) 秒 (范围0-59)
start_date (datetime 或 str) 最早开始日期(包含)
end_date (datetime 或 str) 最晚结束时间(包含)
timezone (datetime.tzinfo 或str) 指定时区

优点：

实现简单，只需要直接创建任务，并将添加到调度器中即可。

缺点：

。。。。。

代码：

普通版本调用：

import schedule
import datetime
import time
import threading
from apscheduler.schedulers.background import BlockingScheduler

def job():
    print("I'm working... in job1  start  {}".format(datetime.datetime.now()))
    # time.sleep(5)
    print("I'm working... in job1  end  {}".format(datetime.datetime.now()))

def job2():
    print("I'm working... in job2        {}".format(datetime.datetime.now()))

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    scheduler.add_job(job, 'interval', seconds=3)  # 间隔3秒钟执行一次
    scheduler.add_job(job2,'interval', seconds=3)  # 间隔3秒钟执行一次
    scheduler.start()  # 这里的调度任务是独立的一个线程

# 结果
I'm working... in job1  start  2020-04-29 17:54:12.657444
I'm working... in job1  end  2020-04-29 17:54:12.657444
I'm working... in job2        2020-04-29 17:54:12.657444
I'm working... in job1  start  2020-04-29 17:54:15.658007
I'm working... in job1  end  2020-04-29 17:54:15.658324
I'm working... in job2        2020-04-29 17:54:15.658554

运行时间大于调用时间：

import schedule
import datetime
import time
import threading
from apscheduler.schedulers.background import BlockingScheduler

def job():
    print("I'm working... in job1  start  {}".format(datetime.datetime.now()))
    time.sleep(5)
    print("I'm working... in job1  end  {}".format(datetime.datetime.now()))

def job2():
    print("I'm working... in job2        {}".format(datetime.datetime.now()))

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    scheduler.add_job(job, 'interval', seconds=3)  # 间隔3秒钟执行一次
    scheduler.add_job(job2,'interval', seconds=3)  # 间隔3秒钟执行一次
    scheduler.start()  # 这里的调度任务是独立的一个线程

# 结果
I'm working... in job1  start  2020-04-29 17:50:17.710468
I'm working... in job2        2020-04-29 17:50:17.726393
Execution of job "job (trigger: interval[0:00:03], next run at: 2020-04-29 17:50:20 CST)" skipped: maximum number of running instances reached (1)
I'm working... in job2        2020-04-29 17:50:20.724602
I'm working... in job1  end  2020-04-29 17:50:22.711978
I'm working... in job1  start  2020-04-29 17:50:23.710288
I'm working... in job2        2020-04-29 17:50:23.727116

假如：我们在执行任务的时候，这个任务的执行时间为5秒，但是调用它是没3秒调用一次，然后会报错。
这是因为任务重复了，看这个解释：

https://pdf-lib.org/Home/Details/10550

我们将这个改了，就好了 ；但是假如执行时间还是很长，那还是把调用时间延长吧。

scheduler.add_job(func2, ‘interval’,max_instances=5, seconds=3)

解决运行时间大于调用时间：

import schedule
import datetime
import time
import threading
from apscheduler.schedulers.background import BlockingScheduler

def job():
    print("I'm working... in job1  start  {}".format(datetime.datetime.now()))
    time.sleep(5)
    print("I'm working... in job1  end  {}".format(datetime.datetime.now()))

def job2():
    print("I'm working... in job2        {}".format(datetime.datetime.now()))

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    scheduler.add_job(job, 'interval', max_instances=3, seconds=3)  # 间隔3秒钟执行一次,允许重复3个相同任务
    scheduler.add_job(job2, 'interval',max_instances=3, seconds=3)  # 间隔3秒钟执行一次，允许重复3个相同任务
    scheduler.start()  # 这里的调度任务是独立的一个线程

# 结果 注意 satrt end 时间
I'm working... in job1  start  2020-04-29 17:48:29.388417
I'm working... in job2        2020-04-29 17:48:29.388417
I'm working... in job1  start  2020-04-29 17:48:32.389530
I'm working... in job2        2020-04-29 17:48:32.390525
I'm working... in job1  end  2020-04-29 17:48:34.389543
I'm working... in job1  start  2020-04-29 17:48:35.390585
I'm working... in job2        2020-04-29 17:48:35.391533
I'm working... in job1  end  2020-04-29 17:48:37.390578
I'm working... in job1  start  2020-04-29 17:48:38.389937
I'm working... in job2        2020-04-29 17:48:38.390813
I'm working... in job1  end  2020-04-29 17:48:40.390838

假如：你的运行时间很大。。。那直接将调用时间延长吧

启动APScheduler进行定时任务
一、运行计划任务的python脚本
如果我们在终端中直接执行的话，关闭终端窗口，Python任务就会中断，Python进程会被杀死,程序将停止运行。可以使用如下命令运行python脚本，

python apschedulerscript.py &

这样执行后及时关闭终端窗口，程序依旧运行。
二、停止计划任务的Python脚本
如何停止呢，可使用如下方法：
其实在执行命令：python apschedulerscript.py &之后会在控制台输出改进程id
例如：

[1] 3057

直接只用kill命令结束即可

kill 3057

如果运行后忘记进程ID，则可遵循下面的方法进行停止

ps -e | grep python

这样将会在终端列出python相关的进程。

916 ? 00:04:05 python
3057 pts/0 00:00:00 python

在这里插入图片描述
使用文件名查找
tasklist | findstr python

可以参考这个文章：

1、https://mp.weixin.qq.com/s/TTUFQRQ_DiKktJ5-J8O8Pg
2、https://blog.csdn.net/wuyongpeng0912/article/details/88895659

关于APScheduler中两种调度器的区别及使用过程中要注意的问题

https://blog.csdn.net/ybdesire/article/details/82228840

关于启动任务

https://www.cnblogs.com/jinxiao-pu/p/9131057.html

apscheduler官网

https://apscheduler.readthedocs.io/en/stable/

备注：
1、当我们使用BcakgroundScheduler()的时候，线程模式，注意while(true)

使用while(true)的作用：
run方法中的代码就是线程要运行的代码，运行完毕以后，就不会再次运行，其方法本身并不是无限循环的。而while(true)是为了让run方法中的代码不断重复的运行，也就是让线程不停的运行，便于查看效果。如果去掉，run运行结束，线程也就结束了。
当然，while(true)并不是run()方法必须的，如果线程的run()部分只需要执行一次，则不需要嵌套while(true)循环。

YUAYU-
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python取消任务的方法_对Python定时任务的启动和停止方法详解
weixin_35838394的博客
03-02 3440
对Python定时任务的启动和停止方法详解在python中我们可以使用APScheduler进行定时任务。APScheduler的具体编码这里就不介绍了。主要说下在终端中启动和停止任务。一、运行计划任务的python脚本如果我们在终端中直接执行的话，关闭终端窗口，Python任务就会中断，Python进程会被杀死,程序将停止运行。可以使用如下命令运行python脚本，python apschedu...
python如何实现多线程定时任务
weixin_42601608的博客
02-01 735
Python可以使用线程库threading来实现多线程，并通过Timer类实现定时任务。代码示例如下： import threading import time def task(): print("Task executed") timer = threading.Timer(5, task) # 5s后执行任务 timer.start() 上面代码中，首先导入了threadi...
Python 实现定时任务的八种方案
最新发布
2401_84204413的博客
04-22 1206
Python中实现定时任务有多种方案，以下是八种常见的实现方式：这是最基础的方法，通过循环和来模拟定时任务。但这种方法效率不高，且不能精确控制时间间隔。是Python的内置模块，可以创建一个定时器来执行特定的任务。是一个轻量级的Python作业调度库，可以方便地设置定时任务。是一个强大的Python定时任务框架，支持多种触发器，并且可以持久化任务。是一个分布式任务队列，用于处理大量消息，同时为操作和维护分布式系统提供简单的方式。它也可以用于定时任务。对于在服务器上运行的任务，可以使用系统的定时任务工具，如L
如何在Python中设置定时任务
挨踢二天才
03-15 2043
无论是使用schedule还是time库，Python都提供了多种设置定时任务的方法。选择哪个库取决于您的具体需求和偏好。如果您需要一个轻量级的库来快速设置简单的定时任务，那么schedule库是一个不错的选择。如果您需要一个更为强大的库来管理复杂的定时任务，那么库是一个更好的选择。而如果您只需要一个Python内置的库来完成简单的定时任务，那么time库是一个不错的选择。希望这篇文章对您有所帮助！如果您想要了解更多关于Python的知识，请查看我们的其他文章和教程！
Python 多线程定时任务（threading+apscheduler）
努力学习的大小宝
09-02 6081
1、代码实现 # -*- coding:utf-8 -*- import os import sys import threading from apscheduler.schedulers.blocking import BlockingScheduler from datetime import datetime import time def timer(n): while True: print(datetime.now().strftime("%Y-%m-%d %H:%
python实现定时任务的几种方案
a961634066的博客
07-19 1544
代码】python实现定时任务的几种方案。
python每天定时执行任务
12-20
Python提供了多种方式来实现定时任务，其中最常用的是使用`schedule`库和`APScheduler`库。本教程将围绕这两个库，结合给定的文件名，探讨如何在Python中设置每天定时执行的任务。 首先，`stock_main.py`可能是主...
python定时任务 每天运行一次.md
03-26
python定时任务 每天运行一次 在 Python 中可以使用 schedule 模块来实现定时任务。以下是一个每天运行一次的例子： import schedule import time def job(): print("I'm running at 5:00am every day.") # 设定...
对Python定时任务的启动和停止方法详解
09-19
今天小编就为大家分享一篇对Python定时任务的启动和停止方法详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
python定时任务 每天运行一次
11-21
python定时任务 每天运行一次
Python实现定时任务
09-21
本篇文章主要介绍了Python实现定时任务，主要有5种方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
python的定时任务框架APScheduler
非空盒子的博客
08-22 223
https://www.jianshu.com/p/338c0a96a60b https://www.jianshu.com/p/4f5305e220f0
Python 定时任务的实现方式
Python热爱者的博客
11-02 1165
背景 目前所在的项目组需要经常执行一些定时任务，于是选择使用 Python 的定时器。 Python 实现定时任务 循环 sleep 这种方式最简单，在循环里面放入要执行的任务，然后 sleep 一段时间再执行 from datetime import datetime import time # 每n秒执行一次 def timer(n): while True: prin...
spring task定时器schedule任务阻塞的解决办法
JaxWan的博客
07-26 7479
任务阻塞分两种：一种是一个定时任务阻塞导致全部定时任务阻塞，第二种是定时任务方法本身阻塞,影响下一次的执行 第一种情况的解决办法：配置线程池的大小 xml配置方式：pool-size="8" <task:annotation-driven scheduler="myScheduler"/> <task:scheduler id="myScheduler" ...
Python实现定时任务的八种方案，干货满满
weixin_56659172的博客
07-02 1760
在日常工作中，我们常常会用到需要周期性执行的任务，一种方式是采用 Linux 系统自带的 crond 结合命令行实现。另外一种方式是直接使用Python。接下来整理的是常见的Python定时任务的实现方式。利用while True: + sleep()实现定时任务使用Timeloop库运行定时任务利用threading.Timer实现定时任务利用内置模块sched实现定时任务利用调度模块schedule实现定时任务利用任务框架APScheduler实现定时任务Job 作业Trigger 触发器Executo
python 使用变量构建另类简单定时器（不阻塞）
chenyulancn的专栏
11-02 2159
在开发中遇到此需求，客户端不断（死循环）向服务器端请求更新的数据，而服务器端每隔X秒才更新一次数据，所以服务器端没有必要在客户端每次请求时都查询数据库，只需每隔X秒查询一次。如果用sleep函数进行等待，该函数是阻塞的自然就延迟了对客户端的响应（客户端可能以此判断与服务器连接断开），因此，不满足需求。我需要的是在客户端请求时先检查数据是否已到更新时间，到了才去检查是否有更新数据，否则不去做检查遍历
python每天定时执行任务_Python设置定时任务
weixin_39866087的博客
12-20 7113
如果需要用Python实现定时任务，包括多长时间之后执行、每隔多久循环执行、每天的几点执行等，都算定时任务。实现定时任务的方法很多，python自身的库也有多种方式可以实现。其中最简单好用的一个库我感觉是threading库中的Timer。比如每隔5秒执行一次：import threadingdef do_job():print('Just do it!')global timertimer = ...
python实现定时任务
10-21
在Python中，可以使用多种方式实现定时任务，下面介绍其中几种常用的方法。 1. 使用time模块和while循环实现定时任务： ```python import time def task(): print("执行定时任务") while True: task() time....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值