去重过滤

在信息流系统中,去重过滤是确保用户体验的关键环节。本文将从技术角度深入探讨去重过滤的设计原则、实现方案和最佳实践。

一、为什么需要去重过滤

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    → 一定不存在

关键在于:布隆过滤器没有假阴性。已插入的元素永远查得到,只有「不存在但说存在」的假阳性。

假阳性率由两个参数决定:

p≈(1−e−nkm)kp \approx \left(1 - e^{-\frac{nk}{m}}\right)^{k}

其中 nn 是元素个数、mm 是位数组长度、kk 是哈希函数个数。工程上常用的经验值是 k=7k = 7,此时 mm 约为 nn 的 1.44 倍,n=100n = 100 万时假阳性率约 0.8%。

元素数量位数组长度哈希函数数假阳性率内存占用
100 万1.44 MB7约 0.8%1.44 MB
1000 万14.4 MB7约 0.8%14.4 MB
1 亿144 MB7约 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 位),并且保证:内容越相似,指纹的汉明距离越小。它的构造过程分四步:

  1. 分词与特征提取。把内容切成特征片段(中文场景常用 n-gram 切分,例如 3-gram)。
  2. 哈希。每个特征片段用哈希函数映射成一个 64 位向量。
  3. 按位累加。对每一位,统计这一位在所有特征向量中为 1 的次数。
  4. 定值。每一位上,累加值大于总特征数一半则该位为 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去重后内容大量缺失(与上一版本对比骤降)可能是指纹计算或阈值被误改
P1L2 相似命中率环比大幅上升阈值过松或出现了大批量搬运内容
P1重复曝光率持续上升去重覆盖不足,需要补规则
P2去重耗时 P99 超预算需要优化或对 L2 做降级
P2L3 行为命中率长期为 0行为去重规则可能没有生效

必须保留的三类对照数据:

  1. 被去重掉的内容样本。定期抽样人工复核,判断这些内容是不是真的重复。去重错误的两种代价不同——误杀优质内容的代价远大于放过一条重复内容,所以复核的抽样应该偏向”被去重但看起来有价值”的内容。
  2. 去重前后的候选池对比。每次调整阈值前后,保存一份候选池快照,用于回溯”如果用另一套阈值会怎样”。
  3. 参数版本与命中的对应关系。每条去重命中记录都要带上当时的阈值配置版本,否则事后无法归因。

降级预案。去重链路上的任何一层都可能超时或不可用,必须预先定义降级顺序:

L2 相似度去重不可用 → 跳过 L2,只执行 L1 与 L3
L1 精确去重也不可用 → 全部跳过,走无去重的兜底结果
候选池不足            → 用同类目内容补齐,并标记为兜底来源

降级触发后要有告警,并且降级期间的内容要打标。这样才能在事后统计”这段时间的重复曝光率上升”是不是降级导致的。

六、最佳实践总结

6.1 去重策略选择指南

场景推荐策略理由
新闻聚合内容指纹 + 相似度新闻内容重复度高
短视频推荐用户行为去重避免重复推荐相同视频
商品推荐业务规则 + 行为去重考虑购买状态和浏览历史
社交动态综合去重需要多维度过滤

6.2 关键注意事项

  1. 去重粒度:根据业务场景选择合适的去重粒度(内容级、作者级、话题级)
  2. 时间窗口:设置合理的去重时间窗口,避免过度过滤
  3. 兜底策略:当去重后内容不足时,要有合适的兜底方案
  4. 性能平衡:在去重效果和响应时间之间找到平衡点
  5. 可配置化:去重参数应支持动态配置,便于快速调整

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”

发现内容有问题?

告诉我们哪里需要改进。