去重过滤
在信息流系统中,去重过滤是确保用户体验的关键环节。本文将从技术角度深入探讨去重过滤的设计原则、实现方案和最佳实践。
1.1 用户体验角度
重复内容是信息流体验的”毒药”。当用户连续看到相同或高度相似的内容时,会产生以下负面感受:
- 疲劳感:重复内容让用户感到乏味,降低浏览兴趣
- 浪费注意力:用户的时间被无效内容占用
- 信任度下降:系统显得不够智能,影响用户信任
1.2 业务指标影响
| 指标 | 未去重 | 去重后 | 提升幅度 |
|---|---|---|---|
| 用户停留时长 | 8.5 分钟 | 12.3 分钟 | +44.7% |
| 内容点击率 | 2.1% | 3.8% | +81% |
| 用户留存率 | 35% | 48% | +37% |
| 负反馈率 | 12% | 4% | -67% |
2.1 基于内容指纹的去重
内容指纹是最基础的去重方式,通过计算内容的唯一标识来判断是否重复。
2.2 基于相似度的去重
对于内容不完全相同但高度相似的情况,需要使用相似度算法。
2.3 基于用户行为的去重
根据用户的历史行为进行个性化去重:
前两类去重是全局的——不管是谁在看,同一篇稿件都只出现一次。但用户视角的重复感还有另一层含义:同一个用户短时间内反复看到同类内容,即使内容本身完全不重复,也会觉得「刷屏」。
行为去重处理的就是这一层。它的判定维度是四个:
| 维度 | 判定依据 | 典型阈值 | 存储位置 |
|---|---|---|---|
| 已曝光内容 | 用户近期是否看过这条内容 | 24 小时内 | Redis Set,按天分区 |
| 作者配额 | 同一作者的连续出现次数 | 连续 3 条 | 请求上下文 |
| 话题配额 | 同一话题在本次候选中的占比 | 不超过 40% | 请求上下文 |
| 主动跳过 | 用户是否跳过或举报过同类内容 | 跳过 2 次即降权 | 用户画像 |
这四个维度的成本差异很大:已曝光集合是一次 SISMEMBER,作者和话题配额是内存里的计数,排序即可。成本从低到高,和精确指纹去重是同一个顺序。
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 基于用户行为的去重过滤器。
*
* 三种判定:
* 1. 已曝光集合:Redis Set 一次 SISMEMBER;
* 2. 作者配额:请求内计数,超限后降权而非直接剔除;
* 3. 话题配额:本次候选中同话题占比超限后跳过。
*/
public class BehaviorDedupFilter {
/** 同一作者连续出现的上限,超过后不再作为重复剔除,只是降权。 */
private static final int AUTHOR_QUOTA = 3;
/** 同一话题在本次候选中的占比上限。 */
private static final double TOPIC_RATIO_LIMIT = 0.4;
/** 已曝光集合的 key 前缀。 */
private static final String EXPOSED_KEY_PREFIX = "user:exposed:";
private final JedisPool jedisPool;
public BehaviorDedupFilter(JedisPool jedisPool) {
this.jedisPool = jedisPool;
}
/**
* 判断候选内容是否因用户行为而被去重。
*
* @param userId 当前用户
* @param candidate 候选内容
* @param kept 本次已经保留的内容,用于计算作者与话题配额
* @param date 曝光集合的分区日期
* @return true 表示应当被去重
*/
public boolean isSaturated(String userId, Candidate candidate, List<Candidate> kept, String date) {
// 第一层:已曝光集合,最便宜
if (alreadyExposed(userId, candidate.contentId(), date)) {
return true;
}
// 第二层:话题配额
if (topicRatioExceeded(candidate, kept)) {
return true;
}
// 第三层:作者配额,超限只降权不剔除
return authorQuotaExceeded(candidate, kept);
}
/**
* 查询用户是否已经曝光过这条内容。
*/
private boolean alreadyExposed(String userId, String contentId, String date) {
String key = EXPOSED_KEY_PREFIX + userId + ":" + date;
try (Jedis jedis = jedisPool.getResource()) {
return Boolean.TRUE.equals(jedis.sismember(key, contentId));
} catch (Exception e) {
// 曝光集合不可用时按未曝光处理,去重是体验优化,不应拖垮主流程
return false;
}
}
/**
* 同一话题在已保留内容中的占比是否超限。
*/
private boolean topicRatioExceeded(Candidate candidate, List<Candidate> kept) {
if (kept.isEmpty()) {
return false;
}
long sameTopic = kept.stream()
.filter(item -> candidate.topic().equals(item.topic()))
.count();
return (double) sameTopic / kept.size() >= TOPIC_RATIO_LIMIT;
}
/**
* 同一作者在已保留内容中的连续出现次数是否超限。
*/
private boolean authorQuotaExceeded(Candidate candidate, List<Candidate> kept) {
long sameAuthor = kept.stream()
.filter(item -> candidate.authorId().equals(item.authorId()))
.count();
return sameAuthor >= AUTHOR_QUOTA;
}
/**
* 用户实际看到内容后,把它写入曝光集合。
*
* 必须在曝光之后写入,而不是在返回候选时写入:
* 后者会把用户根本没看到的内容也算成曝光,导致去重过度。
*/
public void markExposed(String userId, String contentId, String date, int ttlSeconds) {
String key = EXPOSED_KEY_PREFIX + userId + ":" + date;
try (Jedis jedis = jedisPool.getResource()) {
jedis.sadd(key, contentId);
jedis.expire(key, ttlSeconds);
}
}
}
行为去重的三个关键取舍:
- 曝光集合要按天分区。用
user:exposed:{user_id}:{date}而不是把整个用户的历史曝光塞进一个 Set。前者可以整键删除,内存有上限;后者会无限增长,最后一个大 Set 就能把 Redis 拖垮。 - 超限用降权而不是直接剔除。作者超配额不代表内容重复,直接剔除会让优质作者的内容凭空消失。降权的做法是给它一个系数,让它排在后面但仍有机会被看到。
- 曝光写入的时机必须在真正曝光之后。如果在返回候选时就写入,用户往下翻两页没看到的内容也会被记成曝光,去重就变成了「按位置去重」而不是「按用户实际行为去重」。
行为去重的局限:
| 局限 | 原因 | 缓解 |
|---|---|---|
| 依赖曝光回传 | 前端不上报曝光行为,集合就是空的 | 曝光埋点做成可靠上报,宁可延迟不可丢失 |
| 只对同一用户有效 | 跨用户的重复要靠前两层解决 | 与 L1、L2 配合使用 |
| 集合有 TTL | 超过 TTL 的历史行为就忘了 | TTL 按业务周期设置,通常 24 到 72 小时 |
3.1 整体架构
┌─────────────────────────────────────────────────────────────┐
│ 请求入口层 │
│ (API Gateway) │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 去重服务层 │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 指纹去重 │ │ 相似度去重 │ │ 行为去重 │ │
│ │ 模块 │ │ 模块 │ │ 模块 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 存储层 │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Redis │ │ Elasticsearch│ │ MySQL │ │
│ │ (热点缓存) │ │ (相似度索引) │ │ (持久化) │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────┘
3.2 去重流水线
三类去重手段的成本和召回率各不相同,应该按成本从低到高分层执行,把便宜的判断放在前面,尽早短路。
候选内容
│
▼
┌──────────────────────────────────┐
│ L1 精确指纹去重 │ ← 最便宜,命中即结束
│ Redis SET / Bloom Filter │
└───────────────┬──────────────────┘
│ 未命中
▼
┌──────────────────────────────────┐
│ L2 相似度去重 │ ← 成本较高,需要计算指纹
│ SimHash + 海量索引 │
└───────────────┬──────────────────┘
│ 未命中
▼
┌──────────────────────────────────┐
│ L3 行为去重 │ ← 需要用户维度的状态
│ 已曝光集合 / 作者与话题配额 │
└───────────────┬──────────────────┘
│ 通过
▼
进入排序
流水线最重要的设计原则是短路。一旦某一层判定为重复,就不再执行后续层次。一个命中 L1 的请求只花了一次 Redis 查询的成本,而走到 L3 的请求说明它既不是完全重复,也不是高度相似,值得投入更多判断。
import java.util.ArrayList;
import java.util.List;
/**
* 去重流水线。
*
* 三层从便宜到昂贵依次执行,任一层判定重复即短路返回。
*/
public class DedupPipeline {
/** 去重层级。 */
public enum Level { EXACT, SIMILARITY, BEHAVIOR }
/** 去重结果。 */
public record DedupResult(boolean duplicated, Level level, String matchedId, double similarity) {}
/** 候选内容。 */
public record Candidate(
String contentId,
String fingerprint,
long simHash,
String authorId,
String topic,
String category
) {}
/** 命中的重复项记录。 */
public record DuplicateHit(String contentId, Level level, String matchedId, double similarity) {}
/** 去重输出。 */
public record DedupOutcome(List<Candidate> kept, List<DuplicateHit> hits) {}
private final ExactFingerprintIndex exactIndex;
private final SimHashSimilarityIndex similarityIndex;
private final BehaviorDedupFilter behaviorFilter;
public DedupPipeline(
ExactFingerprintIndex exactIndex,
SimHashSimilarityIndex similarityIndex,
BehaviorDedupFilter behaviorFilter) {
this.exactIndex = exactIndex;
this.similarityIndex = similarityIndex;
this.behaviorFilter = behaviorFilter;
}
/**
* 对一批候选内容做去重,返回保留下来的内容及其命中的重复项。
*/
public DedupOutcome dedup(String userId, List<Candidate> candidates) {
List<Candidate> kept = new ArrayList<>(candidates.size());
List<DuplicateHit> hits = new ArrayList<>();
for (Candidate candidate : candidates) {
DedupResult result = check(userId, candidate);
if (result.duplicated()) {
hits.add(new DuplicateHit(candidate.contentId(), result.level(),
result.matchedId(), result.similarity()));
} else {
kept.add(candidate);
}
}
return new DedupOutcome(kept, hits);
}
/**
* 单条内容的三层判定。
*/
private DedupResult check(String userId, Candidate candidate) {
// L1:精确指纹,最便宜
String exactMatch = exactIndex.find(candidate.fingerprint());
if (exactMatch != null) {
return new DedupResult(true, Level.EXACT, exactMatch, 1.0);
}
// L2:SimHash 相似度,计算成本较高
SimHashSimilarityIndex.Match similar = similarityIndex.findNearest(
candidate.simHash(), candidate.category());
if (similar != null) {
return new DedupResult(true, Level.SIMILARITY, similar.id(), similar.similarity());
}
// L3:行为去重,需要读取用户维度的曝光状态
if (behaviorFilter.isSaturated(userId, candidate.authorId(), candidate.topic())) {
return new DedupResult(true, Level.BEHAVIOR, null, 1.0);
}
return new DedupResult(false, Level.EXACT, null, 0.0);
}
}
流水线的三个工程要点:
- 每一层都要有兜底。索引服务不可用时,该层应当判定为「未命中」并继续往下走,而不是让整个请求失败。去重是体验优化,缺失的代价远小于请求报错。
- 相似度索引要按类目隔离。全站内容放在一个索引里做相似度检索,召回的往往不是「同一件事的不同报道」,而是「同一句话被不同账号搬运」。按类目或话题分桶,检索范围小得多,命中率也更高。
- 命中信息要落库。去重命中了什么、命中在哪一层、相似度多少,这些数据是后面第五节做效果监控的基础,也是判断当前去重策略是否过严或过松的唯一依据。
4.1 Bloom Filter 高效去重
对于海量内容的快速去重,布隆过滤器是理想选择:
布隆过滤器解决的是一个具体的工程问题:当待查集合有几亿条、而查询 QPS 很高时,把整个集合放进内存是不现实的。它用一小块内存换来了「大概率正确」的判定。
基本原理:布隆过滤器是一个位数组加若干个哈希函数。插入一个元素时,把每个哈希函数的结果对应的位都置为 1;查询时,只要有一个位是 0,就一定不在集合中;所有位都是 1,则可能在集合中。
插入 content:10086(3 个哈希函数,位数组长度 16):
初始: 0000000000000000
h1 → 3: 0001000000000000
h2 → 7: 0001001000000000
h3 →12: 0001001000001000
查询 content:10086 → 三个位都是 1 → 可能存在
查询 content:99999 → 第 3 位是 0 → 一定不存在
关键在于:布隆过滤器没有假阴性。已插入的元素永远查得到,只有「不存在但说存在」的假阳性。
假阳性率由两个参数决定:
其中 是元素个数、 是位数组长度、 是哈希函数个数。工程上常用的经验值是 ,此时 约为 的 1.44 倍, 万时假阳性率约 0.8%。
| 元素数量 | 位数组长度 | 哈希函数数 | 假阳性率 | 内存占用 |
|---|---|---|---|---|
| 100 万 | 1.44 MB | 7 | 约 0.8% | 1.44 MB |
| 1000 万 | 14.4 MB | 7 | 约 0.8% | 14.4 MB |
| 1 亿 | 144 MB | 7 | 约 0.8% | 144 MB |
Redis 提供了原生的布隆过滤器模块(RedisBloom),命令和普通 key 操作一样简单:
# 创建布隆过滤器,容量 100 万,错误率 0.001
BF.RESERVE content:fingerprint:bf 1000000 0.001
# 加入内容指纹
BF.ADD content:fingerprint:bf content:10086
# 批量加入
BF.MADD content:fingerprint:bf content:10087 content:10088
# 查询是否存在
BF.EXISTS content:fingerprint:bf content:10086
BF.MEXISTS content:fingerprint:bf content:10087 content:10088
# 查看容量与错误率
BF.INFO content:fingerprint:bf
import java.util.List;
/**
* 基于布隆过滤器的精确指纹去重。
*
* 布隆过滤器作为第一道筛子:查得到不代表一定重复(假阳性),
* 查不到一定不重复(无假阴性),所以命中之后还要走一次精确确认。
*/
public class BloomFingerprintIndex {
/** 布隆过滤器 key。 */
private static final String BF_KEY = "content:fingerprint:bf";
/** 精确指纹的 Redis key 前缀,用于消除假阳性。 */
private static final String EXACT_KEY_PREFIX = "content:fingerprint:";
/** 精确指纹的存活时间(秒),与内容去重周期一致。 */
private static final int EXACT_TTL_SECONDS = 604800;
private final JedisPool jedisPool;
public BloomFingerprintIndex(JedisPool jedisPool) {
this.jedisPool = jedisPool;
}
/**
* 查找重复内容。
*
* @param fingerprint 内容指纹
* @return 命中的内容 ID;未命中返回 null
*/
public String find(String fingerprint) {
try (Jedis jedis = jedisPool.getResource()) {
// 第一步:布隆过滤器过滤,这是 O(1) 的位运算
if (!Boolean.TRUE.equals(jedis.bfExists(BF_KEY, fingerprint))) {
return null;
}
// 第二步:假阳性确认,查精确指纹集合
String exactKey = EXACT_KEY_PREFIX + fingerprint;
String contentId = jedis.smembers(exactKey).stream().findFirst().orElse(null);
if (contentId == null) {
// 布隆过滤器说是假阳性,直接把指纹从过滤器里删掉,缩小误判面
jedis.bfDel(BF_KEY, fingerprint);
}
return contentId;
} catch (Exception e) {
// 索引不可用时按未命中处理
return null;
}
}
/**
* 加入内容指纹。
*/
public void add(String fingerprint, String contentId) {
try (Jedis jedis = jedisPool.getResource()) {
jedis.bfAdd(BF_KEY, fingerprint);
String exactKey = EXACT_KEY_PREFIX + fingerprint;
jedis.sadd(exactKey, contentId);
jedis.expire(exactKey, EXACT_TTL_SECONDS);
}
}
/**
* 批量加入内容指纹。
*/
public void addAll(List<String> fingerprints, List<String> contentIds) {
if (fingerprints.isEmpty()) {
return;
}
try (Jedis jedis = jedisPool.getResource()) {
jedis.bfAdd(BF_KEY, fingerprints.toArray(new String[0]));
Pipeline pipeline = jedis.pipelined();
for (int i = 0; i < fingerprints.size(); i++) {
String exactKey = EXACT_KEY_PREFIX + fingerprints.get(i);
pipeline.sadd(exactKey, contentIds.get(i));
pipeline.expire(exactKey, EXACT_TTL_SECONDS);
}
pipeline.sync();
}
}
}
布隆过滤器在这个场景下的取舍:
| 优点 | 代价 | 缓解手段 |
|---|---|---|
| 内存占用极低 | 存在假阳性 | 命中后再查一次精确集合确认 |
| 查询是 O(1) 的位运算 | 不支持删除(RedisBloom 的 BF.DEL 只能按元素删) | 用 TTL 整体过期,不做精细删除 |
| 不需要把全量集合载入内存 | 容量固定,超出后错误率上升 | 用 BF.RESERVE 预留足够容量,超限时告警 |
| 可以跨实例共享 | 无法枚举集合内容 | 枚举需求由精确集合承担 |
容量规划要留足余量。布隆过滤器的容量一旦设错,无法扩容,只能重建——把所有内容重新灌一遍,成本很高。实践中应该按「日增量 × 保留天数 × 3」估算容量,再按预估的峰值留出余量。BF.INFO 返回的 Capacity 和 Size 要持续监控,两者的比值接近 1 就说明容量快满了。
和其他去重方式的关系:
布隆过滤器(内存省、O(1)、有假阳性)
↓ 命中(约 1% 的正常内容会在这里被误判)
精确指纹集合(Redis Set,无假阳性,占用更多内存)
↓ 未命中
相似度索引(SimHash,成本最高)
布隆过滤器的价值在于把绝大多数不重复的内容在第一层就挡掉,让昂贵的相似度计算只处理真正可疑的部分。
4.2 SimHash 相似度去重
SimHash 解决的问题是「内容不完全相同,但高度相似」——比如同一篇稿件被多个账号转载,或者同一段话被配上了不同的标题和封面。
算法原理。SimHash 把一段文本映射成一个固定长度的二进制指纹(通常 64 位),并且保证:内容越相似,指纹的汉明距离越小。它的构造过程分四步:
- 分词与特征提取。把内容切成特征片段(中文场景常用 n-gram 切分,例如 3-gram)。
- 哈希。每个特征片段用哈希函数映射成一个 64 位向量。
- 按位累加。对每一位,统计这一位在所有特征向量中为 1 的次数。
- 定值。每一位上,累加值大于总特征数一半则该位为 1,否则为 0,得到最终的指纹。
import hashlib
from collections import Counter
def shingles(text: str, size: int = 3) -> list:
"""中文场景常用 n-gram 切分。
去掉空白字符后再切分,避免排版差异造成指纹不同。
"""
cleaned = "".join(text.split())
if len(cleaned) <= size:
return [cleaned] if cleaned else []
return [cleaned[i:i + size] for i in range(len(cleaned) - size + 1)]
def hash64(token: str) -> int:
"""把特征片段映射为 64 位指纹。"""
digest = hashlib.md5(token.encode("utf-8")).digest()
return int.from_bytes(digest[:8], "big")
def simhash(text: str, size: int = 3) -> int:
"""计算文本的 SimHash 指纹。"""
features = shingles(text, size)
if not features:
return 0
vector = [0] * 64
for token, weight in Counter(features).items():
h = hash64(token)
for bit in range(64):
if h >> bit & 1:
vector[bit] += weight
else:
vector[bit] -= weight
fingerprint = 0
for bit in range(64):
if vector[bit] > 0:
fingerprint |= 1 << bit
return fingerprint
def hamming_distance(a: int, b: int) -> int:
"""计算两个指纹的汉明距离。"""
return bin(a ^ b).count("1")
def similarity(a: int, b: int) -> float:
"""把汉明距离转换为 0 到 1 的相似度。"""
return 1.0 - hamming_distance(a, b) / 64.0
关键参数的取舍:
| 参数 | 作用 | 调整方向 |
|---|---|---|
| 指纹长度 | 64 位是标准选择 | 位数越多精度越高,但索引占用更大 |
| n-gram 大小 | 决定特征的粒度 | 调小对短文本更敏感,调大对改写更鲁棒 |
| 汉明距离阈值 | 判定重复的界 | 调小更严格(只拦几乎一样的),调大更激进 |
| 片段权重 | 相同片段只计一次 | 加权后,重复出现的片段对指纹影响更大 |
汉明距离阈值怎么定:没有普适值,要用真实数据标定。做法是准备三组样本——完全转载的、同一事件的独立报道的、主题相关但内容不同的——分别计算它们的距离分布,再选一个能把第一组和后两组分开的阈值。经验上,64 位指纹下 3 是一个常见的起点,但必须用自己的数据验证。
索引怎么做:SimHash 的一个重要性质是汉明距离小于 k 的指纹,在多个分段的哈希空间里必然共享至少一个分段。因此可以把 64 位拆成 k+1 段,每段单独哈希建索引,检索时取各段的候选集合的并集,再用完整指纹计算精确汉明距离。这是 SimHash 能支撑大规模检索的关键。
from collections import defaultdict
class SimHashIndex:
"""基于分段哈希的 SimHash 索引。"""
def __init__(self, segments: int = 4, max_distance: int = 3):
self.segments = segments
self.max_distance = max_distance
self.buckets = defaultdict(list)
self.segment_length = 64 // segments
def _segment_keys(self, fingerprint: int) -> list:
keys = []
for index in range(self.segments):
shift = index * self.segment_length
segment = (fingerprint >> shift) & ((1 << self.segment_length) - 1)
keys.append((index, segment))
return keys
def add(self, content_id: str, fingerprint: int) -> None:
for key in self._segment_keys(fingerprint):
self.buckets[key].append((content_id, fingerprint))
def search(self, fingerprint: int, category: str) -> list:
"""检索相似内容,返回按汉明距离升序排列的候选。"""
candidates = set()
for key in self._segment_keys(fingerprint):
for content_id, candidate in self.buckets.get(key, []):
candidates.add((content_id, candidate))
results = []
for content_id, candidate in candidates:
distance = hamming_distance(fingerprint, candidate)
if distance <= self.max_distance:
results.append((content_id, distance))
results.sort(key=lambda pair: pair[1])
return results
SimHash 的局限:
- 对短文本不敏感。特征太少时,指纹的区分度下降,容易把不同的短标题判成相似。短内容更适合用精确指纹加标题归一化。
- 对结构改动敏感。插入或删除大段文字会明显改变指纹。实践中通常只取正文的前若干段参与计算。
- 只识别”几乎一样”,不识别”意思一样”。语义相似需要向量化的方法,SimHash 解决不了改写和概括。
4.3 Redis 去重缓存设计
# 去重缓存的 Key 设计
# 用户已曝光内容(按天分区)
SET user:exposed:{user_id}:{date} {content_id}
EXPIRE user:exposed:{user_id}:{date} 86400
# 全局内容指纹(长期存储)
SET content:fingerprint:{fingerprint} {content_id}
EXPIRE content:fingerprint:{fingerprint} 604800
# 相似度索引(使用 Redis Bloom Filter)
BF.ADD content:similarity:bloom {content_hash}
BF.EXISTS content:similarity:bloom {content_hash}
# 去重计数器(用于限流)
INCR dedup:rate:{user_id}:{minute}
EXPIRE dedup:rate:{user_id}:{minute} 60
5.1 多级缓存架构
请求 → L1 本地缓存 → L2 Redis 缓存 → L3 数据库
(1ms) (5ms) (50ms)
5.2 异步去重处理
对于非实时性要求高的场景,可以采用异步去重:
有些场景并不要求「这一毫秒的内容绝对不能重复」。比如用户翻页时加载的下一页、每日推送的榜单、后台的内容审核队列——这些场景的重复内容最多让用户多看一眼,不会造成实质损失,但实时去重的成本却要一路付出。
同步去重与异步去重的取舍:
| 维度 | 同步去重 | 异步去重 |
|---|---|---|
| 请求延迟 | 每次请求增加 5 到 20 毫秒 | 不增加 |
| 重复内容的出现 | 完全避免 | 可能出现短暂的重复 |
| 资源占用 | 与请求量成正比 | 与内容增量成正比 |
| 实现复杂度 | 低 | 需要引入消息队列与消费端 |
| 结果一致性 | 强 | 最终一致 |
异步去重的核心设计是「先放行,后收敛」:请求链路不做去重,直接返回;去重在异步链路上跑,把重复内容从结果里剔除掉。
内容发布
│
├──► 实时索引(Redis Set / 布隆过滤器) ← 供请求链路查询
│ │
│ ▼
└──► Kafka:content-published 主题
│
▼
去重消费者(批量处理)
│
├──► 命中重复 → 打标 content:duplicate,移出实时索引
└──► 未命中 → 保留,更新去重基线
异步链路上最重要的一点是「标记」而不是「删除」。一旦在异步链路上直接删除内容,删除动作和删除之后到达的请求之间就存在竞态——内容可能刚被删掉,又立刻被写回来。正确做法是打标:把重复内容标记出来,请求链路读到标记时再做过滤。
import java.time.Duration;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* 异步去重消费者。
*
* 从 Kafka 批量消费内容发布事件,对每批内容做去重判定,
* 命中重复的内容打标后移出实时索引。
*
* 批量处理是这个设计的关键:去重的成本主要在相似度索引查询,
* 批量能显著摊薄这部分开销。
*/
public class AsyncDedupConsumer {
/** 去重打标的 Redis key 前缀。 */
private static final String DUPLICATE_KEY_PREFIX = "content:duplicate:";
/** 单批处理的内容数量上限。 */
private static final int BATCH_SIZE = 200;
/** 批次处理的最大耗时(毫秒),超时后提交已处理的部分。 */
private static final long TIME_BUDGET_MILLIS = 500L;
private final JedisPool jedisPool;
private final ExactFingerprintIndex exactIndex;
private final SimHashSimilarityIndex similarityIndex;
public AsyncDedupConsumer(
JedisPool jedisPool,
ExactFingerprintIndex exactIndex,
SimHashSimilarityIndex similarityIndex) {
this.jedisPool = jedisPool;
this.exactIndex = exactIndex;
this.similarityIndex = similarityIndex;
}
/**
* 处理一批内容。
*
* @param batch 本批内容
* @return 被判定为重复的内容数量
*/
public DedupReport consume(List<PublishedContent> batch) {
long start = System.currentTimeMillis();
Set<String> duplicates = new HashSet<>();
int processed = 0;
for (PublishedContent content : batch) {
// 时间预算耗尽就提前结束,剩下的留给下一批
if (processed >= BATCH_SIZE
|| System.currentTimeMillis() - start > TIME_BUDGET_MILLIS) {
break;
}
String matchedId = exactIndex.find(content.fingerprint());
if (matchedId == null) {
SimHashSimilarityIndex.Match similar =
similarityIndex.findNearest(content.simHash(), content.category());
if (similar != null) {
matchedId = similar.id();
}
}
if (matchedId != null) {
duplicates.add(content.contentId());
markDuplicate(content, matchedId);
} else {
// 未命中的内容成为新的去重基线
exactIndex.add(content.fingerprint(), content.contentId());
similarityIndex.add(content.contentId(), content.simHash(), content.category());
}
processed++;
}
return new DedupReport(processed, duplicates.size(), duplicates);
}
/**
* 给重复内容打标。
*
* 打标而不是直接删除:删除会与并发写入产生竞态,
* 打标则是幂等的,重复执行也没有副作用。
*/
private void markDuplicate(PublishedContent content, String matchedId) {
String key = DUPLICATE_KEY_PREFIX + content.contentId();
try (Jedis jedis = jedisPool.getResource()) {
jedis.hset(key, Map.of(
"matched_id", matchedId,
"reason", "similarity",
"marked_at", String.valueOf(System.currentTimeMillis())));
// 打标本身也需要过期,否则标记会无限堆积
jedis.expire(key, 86400);
}
}
}
异步去重的三个工程要点:
- 消费端必须幂等。Kafka 至少一次投递意味着同一条消息可能被消费多次。幂等的做法是:打标用
HSET覆盖写,基线更新用SADD(幂等),而不是追加。 - 消费延迟要监控。异步去重的价值完全取决于延迟。如果消费端积压导致一条内容发布后几分钟才被判定为重复,这段时间内的重复曝光已经发生了。要盯住消费延迟和积压量这两个指标。
- 兜底路径必须保留。异步链路挂掉时,内容库里会堆积未去重的内容。这时要么让去重消费者尽快追平,要么临时把请求链路的同步去重打开。两条路径的开关要能独立控制。
适用场景的判断标准:
| 场景 | 建议 | 原因 |
|---|---|---|
| 首页首屏 | 同步去重 | 重复内容的代价最高,用户第一印象 |
| 用户翻页加载 | 异步去重 | 重复最多造成一次滑动浪费 |
| 每日推送榜单 | 异步去重 | 推送前有充足的批处理时间 |
| 内容审核队列 | 异步去重 | 无实时要求 |
| 搜索结果 | 同步去重 | 结果重复会直接导致用户放弃 |
5.3 去重效果监控
去重是一类效果不容易被直接感知的优化:去重做得好,用户不会夸你;去重做得差,用户也只是觉得”刷屏”然后划走。所以必须主动建立监控体系。
监控要回答四个问题:
| 问题 | 对应指标 | 判断标准 |
|---|---|---|
| 去重是否真的在生效 | 各层级命中率 | 各级都有稳定命中,且 L1 占比最高(最便宜的判断应该承担最多的拦截) |
| 是否去重过度 | 内容供给量、兜底触发率 | 候选内容不足、频繁触发兜底,说明阈值过严 |
| 是否去重不足 | 用户重复曝光率、内容重复投诉 | 重复曝光率上升,说明漏拦了 |
| 代价有多大 | 去重耗时占比、索引存储量 | 耗时占比超出预算,说明需要优化或降级 |
核心指标表:
| 指标 | 定义 | 采集方式 | 异常信号 |
|---|---|---|---|
| L1 精确命中率 | 指纹命中数 / 候选总数 | 流水线埋点 | 骤降说明指纹生成逻辑变了 |
| L2 相似命中率 | SimHash 命中数 / 候选总数 | 流水线埋点 | 突然上升说明阈值调整过松 |
| L3 行为命中率 | 行为去重命中数 / 候选总数 | 流水线埋点 | 持续为 0 说明行为规则未生效 |
| 去重后剩余率 | 保留内容数 / 候选总数 | 流水线埋点 | 低于下界说明过度去重 |
| 兜底触发率 | 触发内容补齐的次数 / 请求数 | 服务埋点 | 高于阈值说明候选池被去重掏空 |
| 重复曝光率 | 同一用户 24 小时内看到的重复内容占比 | 离线统计 | 上升说明去重覆盖不足 |
| 去重耗时 P99 | 流水线执行耗时的 99 分位 | 链路监控 | 超出预算说明需要降级 |
| 索引存量 | 指纹集合与相似度索引的条目数 | 存储监控 | 增速异常说明内容发布量或策略变化 |
告警规则:
| 级别 | 条件 | 含义 |
|---|---|---|
| P0 | 候选池剩余率低于下限且兜底触发率飙升 | 去重逻辑异常,正在影响线上内容供给 |
| P0 | 去重后内容大量缺失(与上一版本对比骤降) | 可能是指纹计算或阈值被误改 |
| P1 | L2 相似命中率环比大幅上升 | 阈值过松或出现了大批量搬运内容 |
| P1 | 重复曝光率持续上升 | 去重覆盖不足,需要补规则 |
| P2 | 去重耗时 P99 超预算 | 需要优化或对 L2 做降级 |
| P2 | L3 行为命中率长期为 0 | 行为去重规则可能没有生效 |
必须保留的三类对照数据:
- 被去重掉的内容样本。定期抽样人工复核,判断这些内容是不是真的重复。去重错误的两种代价不同——误杀优质内容的代价远大于放过一条重复内容,所以复核的抽样应该偏向”被去重但看起来有价值”的内容。
- 去重前后的候选池对比。每次调整阈值前后,保存一份候选池快照,用于回溯”如果用另一套阈值会怎样”。
- 参数版本与命中的对应关系。每条去重命中记录都要带上当时的阈值配置版本,否则事后无法归因。
降级预案。去重链路上的任何一层都可能超时或不可用,必须预先定义降级顺序:
L2 相似度去重不可用 → 跳过 L2,只执行 L1 与 L3
L1 精确去重也不可用 → 全部跳过,走无去重的兜底结果
候选池不足 → 用同类目内容补齐,并标记为兜底来源
降级触发后要有告警,并且降级期间的内容要打标。这样才能在事后统计”这段时间的重复曝光率上升”是不是降级导致的。
6.1 去重策略选择指南
| 场景 | 推荐策略 | 理由 |
|---|---|---|
| 新闻聚合 | 内容指纹 + 相似度 | 新闻内容重复度高 |
| 短视频推荐 | 用户行为去重 | 避免重复推荐相同视频 |
| 商品推荐 | 业务规则 + 行为去重 | 考虑购买状态和浏览历史 |
| 社交动态 | 综合去重 | 需要多维度过滤 |
6.2 关键注意事项
- 去重粒度:根据业务场景选择合适的去重粒度(内容级、作者级、话题级)
- 时间窗口:设置合理的去重时间窗口,避免过度过滤
- 兜底策略:当去重后内容不足时,要有合适的兜底方案
- 性能平衡:在去重效果和响应时间之间找到平衡点
- 可配置化:去重参数应支持动态配置,便于快速调整
6.3 常见问题排查
问题 1: 去重过度,内容太少
解决:调低相似度阈值,扩大候选池
问题 2: 去重不足,重复内容多
解决:增加去重维度,降低时间窗口
问题 3: 去重延迟高
解决:优化缓存策略,采用异步处理
问题 4: 误判率高
解决:结合人工审核,优化算法参数
去重过滤是信息流系统中不可或缺的一环。通过合理设计去重策略、优化系统架构、持续监控效果,可以显著提升用户体验和业务指标。在实际应用中,需要根据具体业务场景灵活调整,找到最适合的去重方案。
参考资料
- Google Research: “Near-Duplicate Detection for Web Pages”
- Facebook: “DeDup: A Framework for Removing Duplicate Content”
- Airbnb Engineering: “Building a Real-time Deduplication System”
发现内容有问题?
告诉我们哪里需要改进。
