从入门到避坑解析Python FastAPI定时任务全攻略

pip install apscheduler

# 项目结构建议
# app/
#   __init__.py
#   main.py       # FastAPI 应用创建和事件处理
#   scheduler.py  # 调度器配置和任务定义
#   tasks.py      # 具体的任务函数

# app/scheduler.py
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.executors.pool import ThreadPoolExecutor

# 1. 配置组件
jobstores = {
    'default': SQLAlchemyJobStore(url='sqlite:///jobs.sqlite')  # 使用SQLite持久化
}
executors = {
    'default': ThreadPoolExecutor(20)  # 线程池执行
}
job_defaults = {
    'coalesce': False,  # 错过的任务是否合并执行（一般False）
    'max_instances': 3  # 同一个任务同时运行的最大实例数
}

# 2. 创建调度器实例
scheduler = AsyncIOScheduler(
    jobstores=jobstores,
    executors=executors,
    job_defaults=job_defaults,
    timezone="Asia/Shanghai"  # 时区！时区！时区！重要的事说三遍
)

# 3. 定义任务函数 (可以放在同文件，也可从其他模块导入)
def my_sync_job():
    print("同步任务执行了！")

async def my_async_job():
    print("异步任务执行了！")
    # 这里可以愉快地调用其他async函数

# 4. 添加任务的函数 (通常在应用启动时调用)
def add_jobs():
    # 间隔任务：每30秒执行一次
    scheduler.add_job(my_sync_job, 'interval', seconds=30, id='sync_interval_job')
    # Cron任务：每分钟的第30秒执行
    scheduler.add_job(my_async_job, 'cron', second=30, id='async_cron_job')
    # 单次任务：2023年10月1日执行
    # scheduler.add_job(xxx, 'date', run_date='2023-10-01 00:00:00')    

# app/main.py
from fastapi import FastAPI
from .scheduler import scheduler, add_jobs

app = FastAPI(title="定时任务演示")

@app.on_event("startup")
async def startup_event():
    # 应用启动时，添加任务并启动调度器
    if not scheduler.running:
        add_jobs()
        scheduler.start()
        print("APScheduler 已启动")

@app.on_event("shutdown")
async def shutdown_event():
    # 应用关闭时，优雅地关闭调度器
    if scheduler.running:
        scheduler.shutdown()
        print("APScheduler 已关闭")

#from contextlib import asynccontextmanager
#@asynccontextmanager
#async def lifespan(app: FastAPI):
#    # 应用启动时，添加任务并启动调度器
#    if not scheduler.running:
#        add_jobs()
#        scheduler.start()
#        print("APScheduler 已启动")
#    yield
#    # 应用关闭时，优雅地关闭调度器
#    if scheduler.running:
#        scheduler.shutdown()
#        print("APScheduler 已关闭")
#app = FastAPI(title="定时任务演示", lifespan=lifespan)

@app.get("/")
async def root():
    return {"message": "Hello World"}

# 可选：提供一个API来手动触发或查看任务状态
@app.get("/jobs")
async def list_jobs():
    jobs = scheduler.get_jobs()
    return {"jobs": [{"id": j.id, "next_run": str(j.next_run_time)} for j in jobs]}    

# 在 scheduler.py 或 startup 事件中
import os
import sys

def try_acquire_lock(lock_file):
    try:
        import fcntl
        f = open(lock_file, 'w')
        # 尝试获取非阻塞的独占锁
        fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
        return f  # 返回文件对象，保持打开状态以持有锁
    except (BlockingIOError, ImportError):
        # 获取失败（其他进程已持有锁）或不支持的系统
        return None

lock_file = "/tmp/fastapi_scheduler.lock"
lock_fd = try_acquire_lock(lock_file)

@app.on_event("startup")
async def startup_event():
    if lock_fd is not None:
        # 只有拿到锁的进程才启动调度器
        if not scheduler.running:
            add_jobs()
            scheduler.start()
            print(f"进程 {os.getpid()} 成功启动 APScheduler")
    else:
        print(f"进程 {os.getpid()} 未获得锁，跳过调度器启动")        

# 假设使用SQLAlchemy ORM
from sqlalchemy.ext.asyncio import AsyncSession
from your_app.models import SchedulerLock
import datetime

async def acquire_db_lock(session: AsyncSession, timeout_minutes=10):
    try:
        # 尝试插入一条锁记录，host和pid标识当前进程
        lock = SchedulerLock(
            id=1,  # 固定ID
            host="my_host",
            pid=os.getpid(),
            last_heartbeat=datetime.datetime.utcnow()
        )
        session.add(lock)
        await session.commit()
        return True  # 插入成功，获得锁
    except IntegrityError:  # 唯一约束冲突，记录已存在
        await session.rollback()
        # 检查已有的锁是否已过期
        existing_lock = await session.get(SchedulerLock, 1)
        if existing_lock and (datetime.datetime.utcnow() - existing_lock.last_heartbeat).seconds > timeout_minutes * 60:
            # 锁已过期，更新为当前进程
            existing_lock.host = "my_host"
            existing_lock.pid = os.getpid()
            existing_lock.last_heartbeat = datetime.datetime.utcnow()
            await session.commit()
            return True
        return False  # 未能获得锁

# 在 startup 事件中调用 acquire_db_lock 判断