牛顿冷却定律

牛顿冷却定律(Newton’s Law of Cooling)是描述物体温度随时间变化的经典物理定律。在热搜榜系统中,我们借用这个定律来模拟内容热度的自然衰减过程。

原理概述

牛顿冷却定律的原始公式为:

dTdt=−k(T−Tenv)\frac{dT}{dt} = -k(T - T_{env})

其中:

  • TT 是物体当前温度
  • TenvT_{env} 是环境温度
  • kk 是冷却系数(正数)
  • tt 是时间

积分后得到温度随时间变化的公式:

T(t)=Tenv+(T0−Tenv)⋅e−ktT(t) = T_{env} + (T_0 - T_{env}) \cdot e^{-kt}

其中 T0T_0 是初始温度。

在热度计算中的应用

在热搜榜场景中,我们将这个公式映射为:

  • 温度 TT → 热度分数
  • 环境温度 TenvT_{env} → 基础热度(通常为 0)
  • 初始温度 T0T_0 → 初始热度分数
  • 冷却系数 kk → 衰减因子

简化后的热度衰减公式为:

Score(t)=Score0⋅e−λtScore(t) = Score_0 \cdot e^{-\lambda t}

其中:

  • Score0Score_0 是内容发布时的初始热度
  • λ\lambda 是衰减系数(控制衰减速度)
  • tt 是内容发布后经过的时间

时间衰减公式实现

基础实现

时间衰减的核心逻辑非常小:一个初始分数乘上一个随时间收缩的因子。下面是最小可用实现。

/**
 * 按牛顿冷却定律计算衰减后的热度分数。
 *
 * @param score0 初始热度分数,即内容发布瞬间的热度
 * @param lambda 衰减系数,取值越大衰减越快,单位为「每小时」
 * @param hours  内容发布至今经过的小时数
 * @return 衰减到当前时刻的热度分数
 */
public static double decay(double score0, double lambda, double hours) {
    if (hours <= 0) {
        return score0;
    }
    return score0 * Math.exp(-lambda * hours);
}

几个容易踩的坑:

  • 单位必须统一。lambda 的单位是「每小时」,如果传入的是秒,就必须把 lambda 同步换算成「每秒」,否则衰减速度会差出 3600 倍。最稳妥的做法是把时间单位写进变量名,而不是靠约定。
  • hours 为负数要挡住。时钟回拨或数据订正都可能产生负的时间差,如果不特判,exp 就会把分数放大成比初始值还大的热度。上面直接对非正数返回 score0,等价于「内容刚刚发布」。
  • score0 为 0 时结果恒为 0,这是数学上的必然,但也意味着「没有初始热度」的内容永远无法靠时间获得曝光,冷启动需要单独处理。

如果更希望用半衰期而不是衰减系数来配置,可以把参数换算成半衰期,语义上更直观:

/**
 * 用半衰期表达衰减:每经过一个半衰期,热度减半。
 *
 * @param halfLifeHours 半衰期(小时),例如 6 表示 6 小时热度减半
 */
public static double decayByHalfLife(double score0, double halfLifeHours, double hours) {
    if (halfLifeHours <= 0 || hours <= 0) {
        return score0;
    }
    return score0 * Math.pow(0.5, hours / halfLifeHours);
}

两种写法的换算关系是 λ=ln⁡(2)/H\lambda = \ln(2) / H,其中 HH 是半衰期(小时)。后面的「不同类型内容的参数建议」会统一用半衰期给出推荐值。

完整的热度计算类

基础实现只解决了「单次衰减」,真实系统还需要处理初始热度的来源、时间基准、精度下限以及并发安全。把这些收敛到一个类里,调用方就只需要关心「给一条内容,返回它现在的热度」。

import java.time.Duration;
import java.time.Instant;
import java.util.function.DoubleSupplier;

/**
 * 基于牛顿冷却定律的热度计算器。
 *
 * 设计要点:
 * 1. 时间基准通过 Clock 注入,便于测试和做时钟漂移校正;
 * 2. 初始热度由调用方传入,本类只负责衰减;
 * 3. 分数低于 minScore 时直接归零,避免大量极小分数占用 ZSet 空间。
 */
public class HeatCalculator {

    /** 衰减系数,单位为「每小时」。 */
    private final double lambda;

    /** 热度下限,低于该值视为已冷却,不再参与排名。 */
    private final double minScore;

    /** 时钟,便于测试时注入固定时间。 */
    private final DoubleSupplier currentTimeMillis;

    public HeatCalculator(double lambda, double minScore, DoubleSupplier currentTimeMillis) {
        if (lambda < 0) {
            throw new IllegalArgumentException("lambda 必须为非负数");
        }
        this.lambda = lambda;
        this.minScore = minScore;
        this.currentTimeMillis = currentTimeMillis;
    }

    /**
     * 计算内容在当前时刻的热度分数。
     *
     * @param initialScore 内容发布时记录的初始热度
     * @param publishedAt  内容发布时间
     * @return 当前热度分数;已低于下限时返回 0
     */
    public double currentHeat(double initialScore, Instant publishedAt) {
        long now = (long) currentTimeMillis.getAsDouble();
        long published = publishedAt.toEpochMilli();
        double hours = (now - published) / 3600000.0;

        // 时钟回拨或数据订正可能导致负的时间差,按「刚发布」处理
        if (hours <= 0) {
            return initialScore;
        }

        double score = initialScore * Math.exp(-lambda * hours);
        return score < minScore ? 0.0 : score;
    }

    /**
     * 计算内容在指定时刻的热度分数,用于回溯历史排名。
     *
     * @param initialScore 内容发布时记录的初始热度
     * @param publishedAt  内容发布时间
     * @param at           要计算的目标时刻
     */
    public double heatAt(double initialScore, Instant publishedAt, Instant at) {
        double hours = Duration.between(publishedAt, at).toMillis() / 3600000.0;
        if (hours <= 0) {
            return initialScore;
        }
        double score = initialScore * Math.exp(-lambda * hours);
        return score < minScore ? 0.0 : score;
    }

    /**
     * 估算内容热度衰减到下限所需的小时数,用于设置条目的过期时间。
     *
     * @return 还需要多少小时热度才会降到 minScore;初始热度本身已低于下限时返回 0
     */
    public double hoursUntilExpired(double initialScore) {
        if (initialScore <= minScore || minScore <= 0) {
            return 0;
        }
        return Math.log(initialScore / minScore) / lambda;
    }
}

几个使用上的约定:

  • 初始热度必须持久化。每次请求都从当前互动量重新算初始热度,等于把衰减又叠加了一次,会让内容热度衰减得过快。正确做法是把「发布时的初始热度」写进存储,后续只做衰减。
  • 本类只做衰减,不做加权。互动量的加权属于多维热度那一层,两层职责混在一起会让参数很难解释。
  • hoursUntilExpired 用来驱动清理。Redis 的条目不可能永久保留,用这个方法算出过期时间后,配合 ZREMRANGEBYSCORE 就能把已经完全冷却的内容批量清掉。

参数调优建议

1. 衰减系数的选择

衰减系数 λ\lambda 决定了热度下降的速度:

衰减系数1 小时后剩余24 小时后剩余适用场景
0.000196.5%39.2%长尾内容、知识类
0.000583.5%2.2%一般资讯
0.00169.7%0.05%热点新闻
0.00248.5%0.0002%突发新闻、短视频

计算公式:如果希望内容在 TT 秒后热度降到原来的 RR 比例:

λ=−ln⁡(R)T\lambda = -\frac{\ln(R)}{T}

2. 使用半衰期配置

半衰期更直观,推荐用半衰期来配置:

用衰减系数 λ\lambda 配置有一个现实问题:它没有物理意义。「λ=0.35\lambda = 0.35」这个数字,业务同学无法判断它意味着什么;而「半衰期 2 小时」直接回答了「这条内容多久热度减半」这个他们真正关心的问题。

换算关系:

λ=ln⁡2H\lambda = \frac{\ln 2}{H}

其中 HH 是半衰期。几个常用换算:

半衰期 HH等价衰减系数 λ\lambda1 小时后剩余6 小时后剩余24 小时后剩余
1 小时0.69350%6.3%0.004%
2 小时0.34771%12.5%0.02%
6 小时0.11689%50%6.3%
12 小时0.05894%71%25%
24 小时0.02997%84%50%

配置应该存半衰期,代码内部可以换算成衰减系数。但更简单的做法是直接用半衰期形式计算——Math.pow(0.5, t / H) 和 Math.exp(-λt) 的结果完全一致,而前者的代码不需要任何换算,参数含义一目了然。

/**
 * 半衰期配置的衰减计算器。
 *
 * 与前面按衰减系数配置的 HeatCalculator 等价,
 * 区别只在于参数直接就是业务能理解的半衰期。
 */
public class HalfLifeHeatCalculator {

    /** 半衰期(小时)。 */
    private final double halfLifeHours;

    /** 热度下限,低于该值视为已冷却。 */
    private final double minScore;

    public HalfLifeHeatCalculator(double halfLifeHours, double minScore) {
        if (halfLifeHours <= 0) {
            throw new IllegalArgumentException("半衰期必须为正数");
        }
        this.halfLifeHours = halfLifeHours;
        this.minScore = minScore;
    }

    /**
     * 计算衰减后的热度分数。
     *
     * @param score0 初始热度分数
     * @param hours  内容发布至今经过的小时数
     */
    public double decay(double score0, double hours) {
        if (hours <= 0) {
            return score0;
        }
        double score = score0 * Math.pow(0.5, hours / halfLifeHours);
        return score < minScore ? 0.0 : score;
    }

    /**
     * 换算为等价的衰减系数,用于与其他按系数配置的模块对接。
     */
    public double lambdaPerHour() {
        return Math.log(2.0) / halfLifeHours;
    }

    /**
     * 估算热度衰减到下限所需的小时数,用于设置条目的过期时间。
     */
    public double hoursUntilExpired(double score0) {
        if (score0 <= minScore || minScore <= 0) {
            return 0;
        }
        // score0 × 0.5^(t/H) = minScore  =>  t = H × log2(score0 / minScore)
        return halfLifeHours * (Math.log(score0 / minScore) / Math.log(2.0));
    }
}

注意 hoursUntilExpired 在两种写法下的表达式不同。按衰减系数时是 ln⁡(score0/min)/λ\ln(score_0 / min) / \lambda,按半衰期时是 H⋅log⁡2(score0/min)H \cdot \log_2(score_0 / min)。两者结果一致,但写反了会得到明显错误的过期时间——因为它直接决定 Redis 里条目的 TTL,设短了内容会被提前清掉,设长了则内存占用超预期。

配置上推荐存半衰期,但要有校验:

# 衰减参数配置:统一用半衰期表达
decay:
  default_half_life_hours: 6.0
  by_content_type:
    breaking_news: 2.0
    news: 6.0
    video: 9.0
    article: 35.0
    tutorial: 144.0
校验项规则原因
半衰期为正必须大于 0为 0 会导致除零,为负会让分数随时间上升
半衰期下界不小于 0.5 小时太短会让内容瞬间消失,榜单刷得比用户翻页还快
半衰期上界不大于 720 小时太长会让过期内容长期滞留,清理任务压力增大
内容类型覆盖未知类型回退到默认值漏配的类型不应导致热度计算失败

半衰期配置带来的额外好处:它让「不同内容类型用不同衰减」这件事在配置层面变得非常自然。前面那份配置里,breaking_news 的 2 小时和 tutorial 的 144 小时相差 72 倍,用衰减系数表达是 0.347 和 0.005 两个看不出差别的数字;用半衰期表达则是「2 小时」和「6 天」,业务同学一眼就能判断合不合理。

3. 不同类型内容的参数建议

衰减系数不该全站统一。不同内容的生命周期差异很大,用同一组参数必然出现「新闻还没热起来就凉了」或者「教程三个月还挂在榜上」。

配置时推荐用半衰期而不是衰减系数,因为「多久热度减半」是业务同学能直接理解的描述。换算关系是 λ=ln⁡(2)/H\lambda = \ln(2) / H:

内容类型推荐半衰期 HH等价衰减系数 λ\lambda选取依据
突发新闻1-3 小时0.23-0.69热点窗口极短,用户注意力几分钟内就会转移,需要快速让位
常规资讯4-8 小时0.09-0.17覆盖一个上午到傍晚的传播周期
短视频6-12 小时0.06-0.12借助推荐分发持续获得长尾流量,衰减比新闻慢
深度长文1-3 天0.01-0.03讨论热度会持续发酵,不宜过早下沉
知识/教程3-7 天0.004-0.008长尾内容靠搜索和收藏持续贡献价值

按半衰期倒推各时间点的剩余比例,同样以突发新闻(H=2H = 2 小时)为例:

经过时间剩余比例说明
1 小时约 71%仍在爆发期
3 小时约 35%已过峰值,进入长尾
6 小时约 13%基本退出主榜
12 小时约 2%接近清理阈值

选参数时按下面几步走,比直接拍数字更可靠:

  1. 先定「上榜时长」。业务上希望一条内容在榜上停留多久?例如突发新闻希望 6 小时内完成绝大部分曝光,那就把半衰期设成 1-3 小时。
  2. 再按内容类型分档。上面的表格就是各档位的起点,不同业务可以在此基础上整体缩放。
  3. 用真实回放验证。拿一段历史数据,按候选半衰期重放,对比线上榜单的实际在榜时长与目标是否一致。
  4. 注意类目之间的相互影响。半衰期过短会让整个榜单刷新过快,用户翻两下就发现榜单全变了,反而失去「热榜」的稳定感。

需要强调的是,这些数值是配置起点而不是最优解。半衰期属于需要 A/B 验证的业务参数,不同用户群体对「热榜应该多久变一次」的容忍度也不一样。

实战示例

完整的热度计算服务

把上面的计算器封装成服务,需要处理四件事:输入输出契约、缓存策略、定时刷新、异常兜底。

import java.time.Instant;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 热度计算服务:对外提供内容当前热度,对内负责缓存与定时刷新。
 */
public class HeatService {

    /** 热度条目。 */
    public record HeatEntry(String contentId, double initialScore, Instant publishedAt) {}

    /** 服务对外返回的结果。 */
    public record HeatResult(String contentId, double heat, boolean expired) {}

    private final HeatCalculator calculator;
    private final ConcurrentHashMap<String, HeatEntry> cache = new ConcurrentHashMap<>();

    public HeatService(HeatCalculator calculator) {
        this.calculator = calculator;
    }

    /**
     * 单条查询:优先读缓存,缓存缺失时回源。
     */
    public HeatResult heatOf(String contentId) {
        HeatEntry entry = cache.get(contentId);
        if (entry == null) {
            // 回源失败时返回空热度,而不是抛异常影响整个榜单
            return new HeatResult(contentId, 0.0, true);
        }
        double heat = calculator.currentHeat(entry.initialScore(), entry.publishedAt());
        return new HeatResult(contentId, heat, heat <= 0);
    }

    /**
     * 批量查询:一次性计算,避免逐条访问带来的往返开销。
     */
    public List<HeatResult> heatOfBatch(List<String> contentIds) {
        return contentIds.stream().map(this::heatOf).toList();
    }

    /**
     * 写入或更新条目的初始热度。初始热度只写一次,之后由衰减逻辑接管。
     */
    public void upsert(HeatEntry entry) {
        cache.put(entry.contentId(), entry);
    }

    /**
     * 定时刷新:清理已经冷却到下限的条目,控制内存占用。
     */
    public void evictExpired() {
        cache.entrySet().removeIf(e ->
            calculator.currentHeat(e.getValue().initialScore(), e.getValue().publishedAt()) <= 0);
    }

    /**
     * 调度周期任务。建议刷新间隔取半衰期的 1/8,
     * 太频繁徒增 CPU,太稀疏则过期条目滞留过久。
     */
    public void scheduleRefresh(ScheduledExecutorService scheduler, long halfLifeHours) {
        long periodSeconds = Math.max(30, (long) (halfLifeHours * 3600 / 8));
        scheduler.scheduleAtFixedRate(this::evictExpired, periodSeconds, periodSeconds, TimeUnit.SECONDS);
    }
}

输入输出契约:对外只暴露 contentId,返回 heat 和 expired 两个字段。这样上层排名逻辑不需要关心衰减参数,也便于在不改接口的前提下调整半衰期。

缓存策略:这里用的是写时更新 + 读时计算的组合。初始热度写入缓存后不再变化,读取时按当前时间实时计算衰减值。好处是缓存里没有「过期的分数」,不会出现缓存里的分数和实际时间对不上的问题;代价是每次读取都要做一次 exp 运算——对于 exp 这种开销很小的函数完全可以接受,换来的是实现简单和不存在缓存一致性问题。

如果单次查询的内容数量很大(比如一次拉取整页 50 条),可以用预计算快照替代:每隔一段时间批量算好所有条目的热度写入缓存,查询时直接读缓存。代价是分数会有一个刷新周期的延迟,需要在业务上确认可以接受。

定时刷新:主要目的是回收内存,而不是更新分数。分数本来就是读时计算的,定时任务只负责把已经冷却到下限的条目从缓存里删掉。

异常兜底:

  • 缓存未命中时返回空热度并标记 expired,而不是抛异常,保证单个条目缺数据不会拖垮整个榜单的查询。
  • 计算层对负数时间差、非法参数都做了前置校验,把错误挡在边界内。
  • 兜底数据建议在服务启动时从持久化存储加载一份快照,即使 Redis 暂时不可用,榜单也能返回一份略微陈旧的结果,而不是空白页。

最后提醒一点:热度服务只负责衰减。真正的分数还要叠加互动权重(多维热度)和用户偏好系数(个性化热度),这三层的职责和调参节奏都不一样,分开实现会让每一层都能独立验证。

注意事项

  1. 避免浮点数精度问题:当热度分数非常小时,可以设置一个最小阈值
  2. 性能优化:对于大量内容,可以缓存计算结果,定期刷新
  3. 冷启动问题:新内容可能需要额外的曝光权重
  4. 时间同步:确保服务器时间一致,避免计算偏差

总结

牛顿冷却定律为热度衰减提供了一个优雅且可解释的数学模型。通过调整衰减系数或半衰期,可以灵活适应不同业务场景的需求。结合互动分数和发布时间,能够构建出既反映实时热度又兼顾内容质量的热搜榜系统。

发现内容有问题?

告诉我们哪里需要改进。