百万级并发下的去重挑战：Bloom Filter 与 Redis 的组合方案

原创

jackcode

发布于 2025-11-06 10:32:47

1560

文章被收录于专栏：爬虫资料爬虫资料

说实话，做采集最怕的是重复抓、抓重复。

你花了一整晚采集到几百万条数据，结果发现有三分之一是重复的，心情立刻从“数据工程师”变成“搬砖机器人”。

尤其在高并发环境下，几百上千个请求一齐发出，URL重叠是常态。

这时候，怎么判断一个URL是不是已经爬过，就成了系统稳定性的关键。

一、问题出现：当 `set()` 不再可靠

我们先看最常见的写法：

if url not in visited:
    visited.add(url)
    crawl(url)

没错，set()查重在小项目里非常方便。

但当你把并发量开到几百甚至几千时，它会带来三个大坑：

内存炸裂：几百万URL直接塞进内存，Python的set()分分钟上GB；
分布式不同步：多节点同时爬，不同机器的visited集合完全不同；
性能急剧下降：哈希查找在高并发下开始抖动，查重延迟越来越高。

我第一次踩这个坑是在采集几个热门新闻网站的时候（包括财新网、第一财经、36氪、虎嗅、澎湃）。

刚开始还挺稳，半小时后服务器内存飙升、Redis报警、日志一堆重复URL。

——那一刻我才明白，“去重”不是功能，而是“防爆机制”。

二、踩坑现场：文件去重也救不了你

后来我想着稳一点，用文件或SQLite数据库来存URL，毕竟这样可以“持久化”，不怕重启丢。

结果更惨。

文件I/O太慢，磁盘写锁频繁争用；SQLite在多线程场景下锁表；整套系统吞吐量直接砍半。

结论：文件去重方案在高并发下基本等于摆设。

三、不同方案的实验报告

于是我开始系统地比较各种方案：

方案	原理	优点	缺点
Bloom Filter	用多个哈希函数映射到位数组	占内存小、速度快	有误判（少量URL被错判为已存在）
Redis HyperLogLog	概率统计唯一值数量	分布式天然支持	只能统计，不支持直接查重
持久化方案（LevelDB/SQLite）	存入本地数据库	可恢复	性能差，不适合高并发

可以看到，没有哪个是“完美方案”。

要么快但不准，要么准但慢。

所以，答案很明显：我们得组合拳出击。

四、最终方案：Bloom Filter + Redis + 持久化备份

最后定下的架构是这样的：

Bloom Filter 负责实时查重，超快；
Redis HyperLogLog 负责全局唯一统计（看总共抓了多少个不同URL）；
文件持久化 定时保存Bloom Filter状态，防止重启丢失。

整个数据流大概长这样：

URL输入 → Bloom Filter查重 → (新URL) → Redis队列 → 爬取 → 存库
                          ↘ 每日写入文件备份

既快、又有一定的安全感。

五、实战代码（含爬虫代理配置）

下面是完整Python示例代码，能跑、能抓、能查重。

我用爬虫代理IP来规避限制，大家可以按需替换自己的账号。

import requests
import mmh3
from bitarray import bitarray
import redis
import time

# ==============================
# 亿牛云爬虫代理配置
# ==============================
PROXY_HOST = "proxy.16yun.cn"   # 代理域名
PROXY_PORT = "31111"        # 端口号
PROXY_USER = "16YUN"  # 用户名
PROXY_PASS = "16IP"  # 密码

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}"
}

# ==============================
# Redis + Bloom Filter配置
# ==============================
redis_client = redis.Redis(host='localhost', port=6379, db=0)
BIT_SIZE = 10 ** 7
HASH_COUNT = 7

class BloomFilter:
    def __init__(self, size, hash_count):
        self.size = size
        self.hash_count = hash_count
        self.bit_array = bitarray(size)
        self.bit_array.setall(0)

    def add(self, item):
        for i in range(self.hash_count):
            digest = mmh3.hash(item, i) % self.size
            self.bit_array[digest] = 1

    def check(self, item):
        for i in range(self.hash_count):
            digest = mmh3.hash(item, i) % self.size
            if self.bit_array[digest] == 0:
                return False
        return True

def fetch_url(url):
    """使用代理请求网页"""
    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        if response.status_code == 200:
            print(f"[OK] {url}")
            redis_client.pfadd("url_counter", url)  # HyperLogLog统计唯一数
            return response.text
        else:
            print(f"[Fail] {url} 状态码: {response.status_code}")
    except Exception as e:
        print(f"[Error] {url}: {e}")

if __name__ == "__main__":
    bloom = BloomFilter(BIT_SIZE, HASH_COUNT)
    urls = [
        "https://www.caixin.com/",
        "https://www.yicai.com/",
        "https://www.36kr.com/",
        "https://www.huxiu.com/",
        "https://www.thepaper.cn/"
    ]

    for _ in range(5):  # 模拟高并发多轮爬取
        for url in urls:
            if not bloom.check(url):
                bloom.add(url)
                fetch_url(url)
            else:
                print(f"[Skip] 已采集过: {url}")
        time.sleep(2)

    # 每日持久化
    with open("bloom_backup.bin", "wb") as f:
        bloom.bit_array.tofile(f)
    print("Bloom Filter 持久化完成。")

    unique_count = redis_client.pfcount("url_counter")
    print(f"Redis HyperLogLog 统计唯一URL数：{unique_count}")

这段代码实际跑下来非常稳：