用python调度作业

Question

我想安排两个不同时间开始的工作。第一个作业需要很多时间，因此我必须在某个小时取消它，以便暂停脚本执行一段时间，然后运行第二个计划作业，但我没有取消第一个作业，它一直在运行，第二个作业从未执行过

我一直在尝试：

from datetime import datetime
import datetime as dt
import schedule

def job1():
   liat = get_LI_AT()
   for doc in db.collection_linkedin.find():
   try:

    if main_scrap.calculate_time(doc['Link']) >= 1:
        rslt = main_scrap.update_company(doc['Link'], liat)
        print(rslt)
        time.sleep(1)

   except:
        print("check ", doc['Link'])
        pass


def job2():
   liat = get_LI_AT()
   main_scrap.companies_scraping(liat)

scheduler1 = schedule.Scheduler()

j = scheduler1.every().day.at('7:30').do(job1)

scheduler2 = schedule.Scheduler()

scheduler2.every().day.at('14:30').do(job2)

while True:

   while datetime.now().time() > dt.time(7) and datetime.now().time() < dt.time(12):
      scheduler1.run_pending()
      time.sleep(1)

  scheduler1.cancel_job(j)

   while datetime.now().time() > dt.time(14) and datetime.now().time() < dt.time(18):
    scheduler2.run_pending()
    time.sleep(1)
  scheduler2.clear()

  time.sleep(5)

还包括：

schedule.every().day.at('7:30').do(job1)  
schedule.every().day.at('14:30').do(job2)

while True:

   if datetime.now().time() > dt.time(7) and datetime.now().time() < dt.time(12):
      schedule.run_pending()
      time.sleep(1)

   elif datetime.now().time() > dt.time(14) and datetime.now().time() < dt.time(18):
        schedule.run_pending()
        time.sleep(1)
 

   time.sleep(5)

我使用过，直到：

schedule.every().day.until("12:00").do(job)
schedule.every().day.until("18:00").do(job)

while True:

   if datetime.now().time() > dt.time(7) and datetime.now().time() < dt.time(12):
      schedule.run_pending()
      time.sleep(1)

   elif datetime.now().time() > dt.time(14) and datetime.now().time() < dt.time(18):
        schedule.run_pending()
        time.sleep(1)
 

   time.sleep(5)

Answer 1

你可以试试simple-scheduler。它的编写正是为了达到这一目的，即长作业不应在调度时隐藏/停止较小作业的执行。以下是一个例子：

该函数的执行时间为x秒，但每5秒和7秒分别调用一次。两个函数完全同时调用。程序不会崩溃，也不会错过未来的运行：

from time import time, ctime, sleep
from simple_scheduler.event import event_scheduler

event_scheduler.timezones()
TZ = "Asia/Kolkata"

def wait(t):
    began_at = ctime(time())
    sleep(t)
    print(f"I waited {t} seconds. [From: {began_at} to {ctime(time())}]")

event_scheduler.add_job(target = wait,
                        kwargs = {"t":5}, # ==> 5 seconds
                        when = ["*|17:24"],
                        tz = TZ)
event_scheduler.add_job(target = wait,
                        kwargs = {"t":7}, # ==> 7 seconds
                        when = ["*|17:24"],
                        tz = TZ)
event_scheduler.run()

输出：

Sat May 22 17:24:12 2021 :: wait [event @sat|17:24|Asia/Kolkata]
Sat May 22 17:24:12 2021 :: wait [event @sat|17:24|Asia/Kolkata]
I waited 5 seconds. [From: Sat May 22 17:24:12 2021 to Sat May 22 17:24:17 2021]
I waited 7 seconds. [From: Sat May 22 17:24:12 2021 to Sat May 22 17:24:19 2021]

Answer 2

在一个线程中运行大作业1，否则它将阻塞主线程，日程安排无法工作（并启动第二个任务）。
在工作1中工作，直到你到达终点

import threading
import time
from datetime import datetime as dt, time as t

import schedule


def job1():
    end_time = t(18)
    while dt.now().time() < end_time:
        print("Job 1 working...")
        time.sleep(1)
    print("Time for job 1 is over")


def job2():
    print("Job 2 working...")


def job1_executor():
    threading.Thread(target=job1).start()


schedule.every().day.at('07:30').do(job1_executor)
schedule.every().day.at('14:30').do(job2)

while True:
    schedule.run_pending()
    time.sleep(1)