牛顿冷却定律
牛顿冷却定律(Newton’s Law of Cooling)是描述物体温度随时间变化的经典物理定律。在热搜榜系统中,我们借用这个定律来模拟内容热度的自然衰减过程。
牛顿冷却定律的原始公式为:
其中:
- 是物体当前温度
- 是环境温度
- 是冷却系数(正数)
- 是时间
积分后得到温度随时间变化的公式:
其中 是初始温度。
在热搜榜场景中,我们将这个公式映射为:
- 温度 → 热度分数
- 环境温度 → 基础热度(通常为 0)
- 初始温度 → 初始热度分数
- 冷却系数 → 衰减因子
简化后的热度衰减公式为:
其中:
- 是内容发布时的初始热度
- 是衰减系数(控制衰减速度)
- 是内容发布后经过的时间
基础实现
时间衰减的核心逻辑非常小:一个初始分数乘上一个随时间收缩的因子。下面是最小可用实现。
/**
* 按牛顿冷却定律计算衰减后的热度分数。
*
* @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);
}
两种写法的换算关系是 ,其中 是半衰期(小时)。后面的「不同类型内容的参数建议」会统一用半衰期给出推荐值。
完整的热度计算类
基础实现只解决了「单次衰减」,真实系统还需要处理初始热度的来源、时间基准、精度下限以及并发安全。把这些收敛到一个类里,调用方就只需要关心「给一条内容,返回它现在的热度」。
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. 衰减系数的选择
衰减系数 决定了热度下降的速度:
| 衰减系数 | 1 小时后剩余 | 24 小时后剩余 | 适用场景 |
|---|---|---|---|
| 0.0001 | 96.5% | 39.2% | 长尾内容、知识类 |
| 0.0005 | 83.5% | 2.2% | 一般资讯 |
| 0.001 | 69.7% | 0.05% | 热点新闻 |
| 0.002 | 48.5% | 0.0002% | 突发新闻、短视频 |
计算公式:如果希望内容在 秒后热度降到原来的 比例:
2. 使用半衰期配置
半衰期更直观,推荐用半衰期来配置:
用衰减系数 配置有一个现实问题:它没有物理意义。「」这个数字,业务同学无法判断它意味着什么;而「半衰期 2 小时」直接回答了「这条内容多久热度减半」这个他们真正关心的问题。
换算关系:
其中 是半衰期。几个常用换算:
| 半衰期 | 等价衰减系数 | 1 小时后剩余 | 6 小时后剩余 | 24 小时后剩余 |
|---|---|---|---|---|
| 1 小时 | 0.693 | 50% | 6.3% | 0.004% |
| 2 小时 | 0.347 | 71% | 12.5% | 0.02% |
| 6 小时 | 0.116 | 89% | 50% | 6.3% |
| 12 小时 | 0.058 | 94% | 71% | 25% |
| 24 小时 | 0.029 | 97% | 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 在两种写法下的表达式不同。按衰减系数时是 ,按半衰期时是 。两者结果一致,但写反了会得到明显错误的过期时间——因为它直接决定 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. 不同类型内容的参数建议
衰减系数不该全站统一。不同内容的生命周期差异很大,用同一组参数必然出现「新闻还没热起来就凉了」或者「教程三个月还挂在榜上」。
配置时推荐用半衰期而不是衰减系数,因为「多久热度减半」是业务同学能直接理解的描述。换算关系是 :
| 内容类型 | 推荐半衰期 | 等价衰减系数 | 选取依据 |
|---|---|---|---|
| 突发新闻 | 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 | 长尾内容靠搜索和收藏持续贡献价值 |
按半衰期倒推各时间点的剩余比例,同样以突发新闻( 小时)为例:
| 经过时间 | 剩余比例 | 说明 |
|---|---|---|
| 1 小时 | 约 71% | 仍在爆发期 |
| 3 小时 | 约 35% | 已过峰值,进入长尾 |
| 6 小时 | 约 13% | 基本退出主榜 |
| 12 小时 | 约 2% | 接近清理阈值 |
选参数时按下面几步走,比直接拍数字更可靠:
- 先定「上榜时长」。业务上希望一条内容在榜上停留多久?例如突发新闻希望 6 小时内完成绝大部分曝光,那就把半衰期设成 1-3 小时。
- 再按内容类型分档。上面的表格就是各档位的起点,不同业务可以在此基础上整体缩放。
- 用真实回放验证。拿一段历史数据,按候选半衰期重放,对比线上榜单的实际在榜时长与目标是否一致。
- 注意类目之间的相互影响。半衰期过短会让整个榜单刷新过快,用户翻两下就发现榜单全变了,反而失去「热榜」的稳定感。
需要强调的是,这些数值是配置起点而不是最优解。半衰期属于需要 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 暂时不可用,榜单也能返回一份略微陈旧的结果,而不是空白页。
最后提醒一点:热度服务只负责衰减。真正的分数还要叠加互动权重(多维热度)和用户偏好系数(个性化热度),这三层的职责和调参节奏都不一样,分开实现会让每一层都能独立验证。
- 避免浮点数精度问题:当热度分数非常小时,可以设置一个最小阈值
- 性能优化:对于大量内容,可以缓存计算结果,定期刷新
- 冷启动问题:新内容可能需要额外的曝光权重
- 时间同步:确保服务器时间一致,避免计算偏差
牛顿冷却定律为热度衰减提供了一个优雅且可解释的数学模型。通过调整衰减系数或半衰期,可以灵活适应不同业务场景的需求。结合互动分数和发布时间,能够构建出既反映实时热度又兼顾内容质量的热搜榜系统。
发现内容有问题?
告诉我们哪里需要改进。
