BitMap：20亿手机号秒级查询？从内存爆炸到高性能架构的演进

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import java.nio.charset.Charset;

public class BloomFilterService {
    private final BloomFilter<String> filter;

    public BloomFilterService() {
        // 预期插入20亿，误判率0.0001
        this.filter = BloomFilter.create(
            Funnels.stringFunnel(Charset.defaultCharset()), 
            2_000_000_000L, 
            0.0001
        );
    }

    public void add(String phone) {
        if (isValid(phone)) filter.put(phone);
    }

    public boolean mightContain(String phone) {
        return isValid(phone) && filter.mightContain(phone);
    }
    
    private boolean isValid(String phone) {
        return phone != null && phone.matches("^1[3-9]\\d{9}$");
    }
}

<!-- Maven 依赖 -->
<dependency>
    <groupId>org.roaringbitmap</groupId>
    <artifactId>RoaringBitmap</artifactId>
    <version>0.9.47</version>
</dependency>

import org.roaringbitmap.RoaringBitmap;

public class RoaringBitmapService {
    private final RoaringBitmap bitmap = new RoaringBitmap();

    public void add(String phone) {
        if (isValid(phone)) {
            // 手机号转为 Long 作为索引
            bitmap.add(Long.parseLong(phone));
        }
    }

    public boolean contains(String phone) {
        return isValid(phone) && bitmap.contains(Long.parseLong(phone));
    }
    
    // 获取内存占用
    public long getMemoryBytes() {
        return bitmap.ramBytesReal();
    }
}

import org.roaringbitmap.RoaringBitmap;
import java.io.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicReference;

public class HighPerformancePhoneService {

    // 原子引用，保证查询线程看到的始终是完整可用的Bitmap
    private final AtomicReference<RoaringBitmap> bitmapRef = new AtomicReference<>(new RoaringBitmap());
    
    private static final String SNAPSHOT_FILE = "phone_bitmap.dat";

    /**
     * 系统启动入口：优先加载快照，若无则异步全量加载
     */
    public void init() {
        File snapshot = new File(SNAPSHOT_FILE);
        if (snapshot.exists()) {
            loadFromSnapshot(snapshot);
            // 后台异步检查增量数据
            asyncIncrementalUpdate();
        } else {
            asyncFullLoadFromDB();
        }
    }

    /**
     * 从磁盘快照快速加载（毫秒/秒级）
     */
    private void loadFromSnapshot(File file) {
        try (FileInputStream fis = new FileInputStream(file);
             DataInputStream dis = new DataInputStream(fis)) {
            
            RoaringBitmap bitmap = new RoaringBitmap();
            bitmap.deserialize(dis);
            bitmapRef.set(bitmap); // 原子替换
            System.out.println("快照加载完成，当前内存占用: " + bitmap.ramBytesReal() / 1024 / 1024 + " MB");
        } catch (IOException e) {
            e.printStackTrace();
            asyncFullLoadFromDB(); // 快照损坏则回退到DB加载
        }
    }

    /**
     * 异步全量从数据库加载（分钟级，后台运行）
     */
    private void asyncFullLoadFromDB() {
        CompletableFuture.runAsync(() -> {
            System.out.println("开始后台全量加载...");
            RoaringBitmap newBitmap = new RoaringBitmap();
            
            // 模拟分批从DB读取，避免OOM
            // while(hasNextBatch) { newBitmap.add(...) }
            
            // 加载完成后，保存快照以便下次快速启动
            try (FileOutputStream fos = new FileOutputStream(SNAPSHOT_FILE);
                 DataOutputStream dos = new DataOutputStream(fos)) {
                newBitmap.serialize(dos);
            } catch (IOException e) {
                e.printStackTrace();
            }

            // 原子切换，对外提供服务
            bitmapRef.set(newBitmap);
            System.out.println("全量加载完成并切换成功。");
        });
    }

    /**
     * 增量更新：通过MQ消费新增手机号
     */
    public void onNewPhoneMessage(String phone) {
        // 注意：RoaringBitmap 是线程安全的吗？
        // RoaringBitmap 本身不是完全线程安全的，写操作需加锁或使用 ConcurrentBitmap
        // 此处简化演示，生产环境建议使用锁或专门的分段锁
        synchronized (bitmapRef) {
            bitmapRef.get().add(Long.parseLong(phone));
        }
    }

    /**
     * 查询接口：微秒级响应
     */
    public boolean checkExists(String phone) {
        if (phone == null || !phone.matches("^1[3-9]\\d{9}$")) return false;
        
        // 获取当前时刻的快照引用，确保一致性
        RoaringBitmap currentBitmap = bitmapRef.get();
        return currentBitmap.contains(Long.parseLong(phone));
    }
}