一、引言:定时任务为什么会“闹脾气”

做后端开发的朋友,几乎都跟定时任务打过交道。你以为设定好时间,它就会乖乖按点执行,可现实往往是:要么那天它压根没跑,要么跑了好几次。更麻烦的是,漏执行和重复执行还会带来连锁反应,比如用户重复收到邮件、订单状态被覆盖、账单被多扣一次钱。这些问题在 Ruby on Rails 项目里尤其常见,因为 Rails 应用往往要同时处理 Web 请求和后台任务,稍有不慎,cron 配置、进程管理、任务锁这些环节就会出岔子。

这篇文章不灌概念,直接用实际代码和踩坑经历,把漏执行和重复执行这两大难题拆开揉碎,看完你就能自己动手修好它们。

二、技术选型:我们用哪些工具

要解决定时任务的问题,光靠 Rails 自带的东西是不够的。我们一般会用到三个主力:

  • whenever:用来把任务定义转换成 cron 格式,方便统一管理定时时间。
  • Sidekiq:Rails 里最常用的后台任务框架,能处理异步任务,还自带重试机制。
  • Redis:充当 Sidekiq 的队列存储,同时也能做“锁”,防止重复执行。

当然,你也可以用其他方案,比如 Delayed Job、Resque,或者直接用 Linux 的 crontab 写 shell 脚本。不过下面所有示例都统一使用 Ruby on Rails + whenever + Sidekiq + Redis 这套技术栈,保证你照着做就能跑起来。

三、漏执行的原因与解决

漏执行就是该跑没跑。常见原因有两个:一个是 cron 配置没生效或者被覆盖,另一个是任务跑着跑着崩溃了,没人管它。

3.1 服务器重启导致 cron 丢失

很多人用 whenever 配置任务后,只记得部署时执行 whenever --update-crontab,但服务器一旦重启,cron 服务可能不会自动加载你的配置。尤其是裸机部署、用 Docker 或者 Kubernetes 时,cron 服务经常没起来。

解决办法是写一个启动脚本,在服务器启动时自动更新 cron。比如用 config/schedule.rb 定义任务:

# 技术栈:Ruby on Rails + whenever

# 每天凌晨 3 点执行清理任务
every 1.day, at: '3:00 am' do
  runner "CleanupWorker.perform_async"
end

# 每 30 分钟同步一次用户积分
every 30.minutes do
  runner "SyncPointsWorker.perform_async"
end

然后在部署脚本里加上更新命令:

# 技术栈:Shell

# 部署完成后,强制更新 crontab
bundle exec whenever --update-crontab --set environment='production'

如果你用的是 Docker,可以在 CMD 里同时启动 cron 和 Rails 应用:

# 技术栈:Shell

# 启动 cron 服务,然后启动 Rails
service cron start
bundle exec whenever --update-crontab
bundle exec puma -C config/puma.rb

3.2 任务异常崩溃没有重试

即使 cron 按时触发了,任务内部也可能出错。比如网络超时、数据库锁等待、外部 API 返回异常。如果任务像一根筋一样只跑一次,失败就彻底消失了,这就是漏执行的第二个典型场景。

Sidekiq 自带重试机制,你只需要在 Worker 里定义好重试次数和间隔:

# 技术栈:Ruby on Rails + Sidekiq

class CleanupWorker
  include Sidekiq::Worker

  # 出错后最多重试 5 次,第一次等 10 秒,之后按指数退避
  sidekiq_options retry: 5, backtrace: true

  def perform
    # 模拟清理逻辑,如果数据库暂时不可用,会抛出异常
    User.where("last_seen_at < ?", 30.days.ago).delete_all
  rescue => e
    # 记录日志,方便排查
    Rails.logger.error("清理任务失败:#{e.message}")
    raise e  # 重新抛出,让 Sidekiq 执行重试
  end
end

注意,很多漏执行不是 cron 没触发,而是任务失败后没人重试。有了 Sidekiq 的重试机制,漏执行的概率会大大降低。

四、重复执行的原因与解决

重复执行比漏执行更隐蔽,也更危险。它一般发生在两种情况:多个服务器实例同时跑同一个任务,或者任务执行时间超过了 cron 的间隔。

4.1 多实例部署时任务被同时执行

现在大型应用基本都横向扩展,同一个 Rails 应用可能跑在好几台服务器上。如果每台机器都配置了 cron,那么同一个任务就会被触发多次。比如三台服务器,每台都会跑一次清理任务,结果就是数据被重复处理。

解决思路很简单:只让一台机器执行 cron。但有时候因为历史原因,你没法轻易改动所有机器的 cron 配置,那就在任务层面加锁,保证同一时间只有一个实例能执行。

4.2 任务耗时超过周期

假设你设置每 5 分钟跑一次同步任务,但同步逻辑本身可能要跑 10 分钟。那第二次触发的任务就会跟第一次的任务重叠,造成重复处理。这种情况即便只有一台服务器也会发生。

4.3 用 Redis 实现“任务锁”

最快见效的办法是使用 Redis 的 SET NX 指令。同一时间只有一个任务能拿到锁,其它任务直接放弃或者等下一轮。

下面是一个通用锁模块:

# 技术栈:Ruby + Redis

require "redis"

class TaskLock
  def initialize(key, expire_seconds)
    @key = "task_lock:#{key}"
    @expire_seconds = expire_seconds
  end

  # 尝试获取锁,成功返回 true,失败返回 false
  def acquire
    # NX 表示只有 key 不存在时才能设置成功
    result = Redis.current.set(@key, "locked", nx: true, ex: @expire_seconds)
    result == "OK"
  end

  def release
    Redis.current.del(@key)
  end
end

然后在 Worker 里这样使用:

# 技术栈:Ruby on Rails + Sidekiq

class SyncPointsWorker
  include Sidekiq::Worker
  sidekiq_options retry: 0

  def perform
    lock = TaskLock.new("sync_points", 300)  # 锁 5 分钟

    # 如果拿不到锁,说明已经有任务在跑了,直接返回
    return unless lock.acquire

    begin
      # 模拟同步用户积分
      User.find_each do |user|
        user.points += calculate_points(user)
        user.save!
      end
    ensure
      lock.release
    end
  end

  private

  def calculate_points(user)
    # 这里假装有复杂的积分计算逻辑
    rand(10)
  end
end

加了这个锁之后,假设有三台服务器同时触发任务,只有第一台能拿到锁,另外两台会直接返回,等下一次 cron 触发。如果任务真的需要每 5 分钟执行一次,而执行时间又不到 5 分钟,这个方案完全够用。

五、案例:一个完整的定时任务模块

把上面这些知识点串起来,写一个完整的“订单超时关闭”功能。需求是:每 5 分钟扫描一次未付款订单,如果超时 30 分钟就自动取消,同时发送通知邮件。要求不能漏执行,也不能重复关闭订单。

5.1 配置 Gemfile

# 技术栈:Ruby on Rails

# 定时任务解析
gem "whenever", require: false

# 后台任务框架
gem "sidekiq"

# Redis 连接
gem "redis"

5.2 定义 cron 任务

# 技术栈:Ruby on Rails + whenever
# 文件:config/schedule.rb

every 5.minutes do
  runner "CloseExpiredOrdersWorker.perform_async"
end

5.3 实现带重试和锁的 Worker

# 技术栈:Ruby on Rails + Sidekiq
# 文件:app/workers/close_expired_orders_worker.rb

class CloseExpiredOrdersWorker
  include Sidekiq::Worker

  # 失败重试 5 次,同时避免无限重试造成重复
  sidekiq_options retry: 5, dead: true

  def perform
    lock = TaskLock.new("close_expired_orders", 300)

    # 没拿到锁就返回,防止多实例重复执行
    return unless lock.acquire

    begin
      # 找出超时未付款的订单
      expired_orders = Order.where(status: "pending")
                            .where("created_at < ?", Time.current - 30.minutes)

      expired_orders.find_each do |order|
        # 幂等操作:只有 pending 状态才会被关闭,避免重复关闭
        if order.pending?
          order.update!(status: "cancelled", cancelled_at: Time.current)

          # 发送通知邮件(此处异步发送)
          OrderMailer.order_expired(order).deliver_later
        end
      end
    rescue => e
      Rails.logger.error("关闭超时订单失败:#{e.message}")
      raise e  # 触发 Sidekiq 重试
    ensure
      # 确保锁一定会被释放,否则会死锁
      lock.release
    end
  end
end

5.4 完善 TaskLock

刚才的 TaskLock 有个小问题:如果任务执行时间超过锁的过期时间,锁会被 Redis 自动删除,然后另一个任务就能拿到锁。更稳妥的做法是在释放锁时校验是不是自己的锁。这里我们给锁加上唯一标识:

# 技术栈:Ruby + Redis
# 文件:app/models/task_lock.rb

class TaskLock
  attr_reader :token

  def initialize(key, expire_seconds)
    @key = "task_lock:#{key}"
    @expire_seconds = expire_seconds
    @token = SecureRandom.uuid
  end

  def acquire
    # 使用 SET NX EX,同时设置唯一 token
    result = Redis.current.set(@key, @token, nx: true, ex: @expire_seconds)
    result == "OK"
  end

  def release
    # 删除前先询问一下这个人是不是自己
    script = <<~LUA
      if redis.call("get", KEYS[1]) == ARGV[1] then
        return redis.call("del", KEYS[1])
      else
        return 0
      end
    LUA

    Redis.current.eval(script, keys: [@key], argv: [@token])
  end
end

这段 Lua 脚本是 Redis 官方推荐的做法,它保证了“只有锁的持有者才能释放锁”,防止任务 A 把任务 B 的锁给释放掉。

5.5 开启 Sidekiq

别忘了启动 Sidekiq 进程,否则 perform_async 只是把任务丢进队列,没人去执行。在 config/initializers/sidekiq.rb 里配置好 Redis 连接:

# 技术栈:Ruby on Rails + Sidekiq

Sidekiq.configure_server do |config|
  config.redis = { url: "redis://localhost:6379/0" }
end

Sidekiq.configure_client do |config|
  config.redis = { url: "redis://localhost:6379/0" }
end

然后在项目根目录执行:

# 技术栈:Shell

bundle exec sidekiq

现在这个订单关闭任务已经具备防漏、防重复的能力了。

六、注意事项

定时任务看起来简单,真正跑在生产环境里,还有一堆细节需要留意。

6.1 时区问题

cron 默认使用服务器所在时区,而 Rails 应用有自己的时区配置。如果你在 schedule.rb 里写 at: '3:00 am',实际执行时间可能跟你想的不一样。建议在 application.rb 里统一时区,同时在部署时确认服务器时区:

# 技术栈:Ruby on Rails

config.time_zone = "Asia/Shanghai"
config.active_record.default_timezone = :local

6.2 任务幂等

锁只是第一道防线,最根本的还是让任务本身具备幂等性。什么叫幂等?就是无论执行一次还是一百次,结果都一样。比如订单关闭,只允许把“pending”状态改成“cancelled”:

# 技术栈:Ruby on Rails

# 只有 pending 才能被更新,否则 SQL 返回 0 行
Order.where(id: order.id, status: "pending")
     .update_all(status: "cancelled", cancelled_at: Time.current)

用 update_all 并且带条件,比先查再更新更安全,也能防止并发重复更新。

6.3 锁的超时时间

锁的过期时间一定要大于任务最长的执行时间。如果你设了 30 秒,但任务要跑 60 秒,锁中途就自动没了,这时候就会有第二个任务同时进来。建议超时时间设置成任务正常耗时的 3 到 5 倍,并且在任务内部用 renew 机制延长锁的存活时间。更专业的做法是使用 sidekiq-unique-jobs 这一类的 gem,不过自己实现锁能帮你更深入理解原理。

6.4 日志和监控

定时任务最容易出问题时,你却不知道它出问题了。所以一定要记录日志,并且设置监控。最简单的方法是通过 Rails logger:

# 技术栈:Ruby on Rails

Rails.logger.info("开始关闭超时订单,当前时间:#{Time.current}")

进阶方案是把任务执行结果推送到监控系统,比如 Elasticsearch + Kibana,或者接入 Alert Manager。总之,当任务连续失败 N 次时,你的手机必须收到告警。

6.5 手动补偿机制

不管写多少保护逻辑,总会有极端情况:比如 Redis 服务挂了、数据库迁移导致锁表、或者你忘了部署 schedule.rb。所以设计一个“手动补偿”的后台页面或者 rake 任务,可以让你在紧急时刻手动触发一次完整执行。

# 技术栈:Ruby on Rails

# 手动执行关闭超时订单,忽略锁
# 文件:lib/tasks/orders.rake

namespace :orders do
  desc "手动关闭超时订单"
  task close_expired: :environment do
    orders = Order.where(status: "pending")
                  .where("created_at < ?", Time.current - 30.minutes)
    orders.find_each do |order|
      order.update!(status: "cancelled", cancelled_at: Time.current)
    end
  end
end

运行命令:

# 技术栈:Shell

bundle exec rake orders:close_expired

七、总结

定时任务不像 Web 请求那样有来有回,它的失败往往是悄无声息的。漏执行像是一个人放了你的鸽子,重复执行像是一个快递帮你送了三遍。要解决这两个问题,核心思路并不复杂:用 whenever 管好 cron 配置,用 Sidekiq 的重试机制兜住异常,用 Redis 锁挡住并发冲突,再让每个操作尽量幂等。把这些环节扣在一起,你就能在各种复杂环境里,让定时任务像闹钟一样靠谱。

当然,没有一劳永逸的方案。每一次定时任务的异常,都是对你代码健壮性的一次考验。希望这篇文章能帮你把这些坑提前填平,让你的 Rails 应用跑得更稳。