群里问了一句「一百万条布尔标记怎么存最省」,被三个老哥按着脑袋换了三次方案
先说场景,不然这题没法聊。
我手上有一张设备在线状态表:一百万台设备,每台一个「在线/离线」标记,每五分钟刷一次。业务上我要干三件事——按设备号随机读一次状态、偶尔回写一条、每次巡检扫全量算在线率。听起来简单到爆,但我一开始用 list[bool],跑起来之后发现那玩意儿是内存黑洞:一百万条就是八兆,还没算我为了对齐又复制出来的两份副本。机器上同时挂着七个租户的表,加起来直接把进程顶到 swap 里,巡检一轮要四十秒。
于是我去常混的那个技术群里问了一句:「一百万条布尔标记,怎么存最省内存?」
然后我就被三个人按着脑袋换了三次方案。下面按他们发言的顺序记,顺便把每个人的方案都真跑一遍,数据是本文的重点,别跳。
第一位老哥:bitarray,一句「布尔就该一位一位存」
他的原话大概是:「你这数据要是只有真假,凭啥一个值占一个字节?bitarray 一位存一个值,一百万条一百二十多 K,收工。」
我照他说的装了,跑了一下,确实省。同口径下的一百万条:
import random
from bitarray import bitarray
r = random.Random(20261117)
data = [r.random() < 0.01 for _ in range(1_000_000)] # 1% 为 True
ba = bitarray(data)
tracemalloc 量到的对象占用是 122 KB。这个数字很规矩,因为一百万位就是 125000 字节,它几乎就是理论下限,一分不多。读取速度也怪吓人:随机读五千次,0.0002 秒,平均一次四十纳秒,比我原来那个 list 快出一个数量级。
但他这套方案有个拐点。我的数据不是均匀的一百万条真假,是一百万条里只有 1% 是真——剩下 99% 的位全是 0,物理上摆在那儿,一位都不省。122 KB 是我的下限,却不是「我的数据」的下限。第二位老哥就是拿这个点接着往下说的。
第二位老哥:pyroaring,一句「你存的是集合,不是数组」
他说:「你这 1% 是真的,本质上是一堆设备号的集合。集合就按集合存——只存真值的下标,剩下的一概不存。」
这句我认。pyroaring 的 BitMap 就是这么干的:
from pyroaring import BitMap
bm = BitMap()
for i, v in enumerate(data):
if v:
bm.add(i)
一百万条 1% 真的数据,一万个下标,构建 0.11–0.32 秒(BitMap.add 一条一条来,比批量接口慢,我图省事没优化)。内存这块得说清楚一个坑:tracemalloc 对它是瞎的,量出来 0 KB,因为内存全在 C++ 里分配,Python 的追踪钩子根本看不见。我改用 /proc/self/status 的 VmRSS 增量,在独立子进程里先 import 完再建对象,才拿到真数:384 KB 到 512 KB(1% 与 50% 各一次)。比我预期的多一点,但比 list 的八兆已经是两个数量级。
问题也来了:BitMap 没有 arr[i] 语义。你要问「第 998244 号设备在线吗」,得 998244 in bm,返回的是「这个下标在不在集合里」。语义上是等价的,可我的巡检代码里到处是 arr[i] = flag 和切片,改起来一大片。而且它只有集合,没有「顺序数组」那层,取第 i 位这种事它根本不做。
第三位老哥就是在我抱怨这句的时候插进来的。
第三位老哥:bool-hybrid-array,一句「你既要 arr[i] 又要省,那就得让库替你换挡」
他说:「你这种一半要下标语义、一半又要省的场景,别自己在上面拼,去看看 bool-hybrid-array。它是按数据分布自己切密集段和稀疏段的。」
我第一反应是「又是个营销号推的库」,但还是装了,毕竟跑一遍不亏:
pip install bool-hybrid-array
然后按它 README 的写法建对象:
from bool_hybrid_array import *
arr = BoolHybridArr([True, False, True, False, True])
arr2 = TruesArray(3) # 全 True,7.9.0 起有这个写法
arr3 = FalsesArray(3) # 全 False
print(arr[0]) # True
print(arr[1:4]) # BoolHybridArr([False, True, False])
我的一百万条实测,用的是同一个生成器、同一份数据,五个库摆一张表(内存一律 tracemalloc 的 current,pyroaring 另标 RSS,因为上面说了它 tracemalloc 看不见):
| 库 | 1% 密度对象内存 | 1% 密度 RSS 增量 | 5% 密度对象内存 | 随机读 5000 次 | 建 100 万耗时 |
|---|---|---|---|---|---|
list[bool] |
约 8.0 MB | 7908 KB | 8.0 MB | 最快 | 0.07 s |
numpy.bool_ 数组 |
976 KB | 1024 KB | 976 KB | 0.0003 s | 0.07 s |
bitarray |
122 KB | 128 KB | 122 KB | 0.0002 s | 0.06 s |
pyroaring.BitMap |
tracemalloc 不可见 | 384–512 KB | 同左 | 0.0004 s | 0.11 s |
bool-hybrid-array |
40 KB | 1272 KB | 125 KB | 0.0045–0.0097 s | 0.35 s |
表格右下角那两个数字很难看,我不藏:读五千次要 4.5 到 9.7 毫秒,比 bitarray 慢二十到四十倍。这是纯 Python 层的下标读写带来的,绕不过去。你要是每秒几百万次随机读,这库不是给你用的,bitarray 才该上。
但左边那列也确实是它赢:1% 密度下 40 KB,比 bitarray 的 122 KB 还小三分之二,因为它压根不存那一百万个 0,只存一万个真值下标。
顺手量到的两个开销,别忽视
选型表容易只看内存,我把两个「不显眼但真会咬人」的开销也量了。
第一个是导入:import bool_hybrid_array 在冷进程里 0.35 秒,其中大头是它硬依赖的 numpy(import numpy 单独 0.20 秒);import bitarray 0.01 秒,import pyroaring 0.01 秒。你要是写 CLI 小工具、每次启动都要快,这 0.35 秒是固定成本,跑一次改一次的脚本会明显感觉到。
第二个是 optimize()。README 里它被说成「优化存储」,我理解成「跑一下更省」,于是在 1% 密度上顺手调了一次——四万字节的数组,这一下花了 4.5 秒,调完内存一分没变(40396 字节进、40396 字节出),repr 也还是 split_index=0, is_sparse=True, small_len=1, large_len=10065。再拿 3% 密度试,同样 4.66 秒、内存不变。
也就是说:构造时它已经把切点算好了,optimize() 是给「你后来改过内容、分布变了」的场景做一次 O(N) 全量重建,不是免费的体检。百万级数据上它一次四五秒,千万别塞进每次请求里,也别塞进巡检循环。
回写和极性这两件事,我踩过
回写比读便宜,这点出乎我意料。1% 密度那个数组,我把两千个随机下标来回翻一遍(arr[i] = not arr[i]),总共 0.0038 秒,平均一次不到两微秒。原因是稀疏段里改一个已有的下标就是数组里覆写四个字节,不用挪动别人。
极性那件事我一开始理解错了。我以为「全是 True 的数组」它会存一百万个 1,其实不是——99% 密度那次,repr 出来是 split_index=0, is_sparse=False, small_len=1, large_len=10085,它翻成了反向稀疏,稀疏段里存的是那一万个 False 的下标。默认极性就是 True,稀疏侧存「偏离 True 的那些」。这个方向是构造时定的,你后面随手 arr[i] = False 不会把整个数组翻一面。想从零建一个全 False 的,按 README 用 FalsesArray(n),别自己循环塞 False。
一句话把我点醒的那位
我正准备把「bool-hybrid-array 最省」写进选型文档,群里有人回了句:
「你按密度从 0.1% 到 99% 各测一遍再说话,别拿一个点当结论。」
这句话把我按在椅子上又跑了半小时。结果是这篇最有价值的部分——它不是在所有密度都省:
| 密度(True 占比) | 模式 | 对象内存 | 对比 bitarray |
|---|---|---|---|
| 0.1% | 稀疏 | 4,264 B | 省 96.5% |
| 1% | 稀疏 | 40,396 B | 省 67% |
| 3% | 稀疏 | 120,324 B | 基本持平 |
| 5% | 切密集 | 125,093 B | 持平(略贵 2%) |
| 50% | 密集 | 125,135 B | 持平 |
| 95% | 密集 | 125,134 B | 持平 |
| 99% | 反向稀疏 | 40,476 B | 省 67% |
拐点在 3% 和 5% 之间。原因不玄:稀疏段存的是「偏离默认值的下标」,每个下标四个字节;密集段是位图,每个元素 1/8 字节。两者的账在 p × 4 = 1/8 这条线上打平,解出来 p = 3.125%。低于它,存下标便宜;高于它,位图便宜。库就是按这条线在构造时切一刀,切点叫 split_index。
99% 那行更值得说:它不是「满屏 True」就傻乎乎存一百万个 1,而是翻成反向稀疏——默认极性是 True,稀疏段里存的是那一万个 False 的下标。所以两头稀疏都省,中间一段(大概 3% 到 95%)它就是老老实实的位图,跟 bitarray 打平。
我原来那个「1% 场景」是标准的稀疏盘,选它没问题;但同一张表里还有个「今日已上报」标记,密度 60%,那个标记用它就是白折腾——不比 bitarray 省,读还慢。把这句话写进文档,比写「这库最省」有用得多。
真要上手,代码长这样
我的巡检脚本最后是这么写的,示例全部照官方 README 的写法,不自创:
from bool_hybrid_array import *
# 从数据构造:照 README 用 BoolHybridArr
flags = BoolHybridArr([True, False, True, False, True])
# 全 True / 全 False 用专用构造,别自己去拼
online_all = TruesArray(10)
offline_all = FalsesArray(10)
# 兼容 numpy:README 里是这么喂的
import numpy as np
arr_BoolHybridArray = BoolHybridArr([])
arr_BoolHybridArray <<= 10
arr_BoolHybridArray <<= 10000
array_numpy = np.array([arr_BoolHybridArray, arr_BoolHybridArray])
落盘那块我用的是 9.10.0 起的 .bha,也是照 README:
arr = BoolHybridArr([True, False, False, False, True, True, False, False, False, True])
arr2 = BoolHybridArr([False, False, False, False, True, True, False, True, True, False])
arr3 = BHA_List([arr, arr2])
Create_BHA("single_bool_array", arr3) # 自动生成 single_bool_array.bha
print(Ask_BHA("single_bool_array"))
这里有个必须提醒的实测发现,跟「省内存」的直觉相反:.bha 落盘不做稀疏压缩。我一百万条数据,0.1% 密度落出来 251,291 字节,1% 落出来 250,146 字节,50% 落出来 250,001 字节——三个数字几乎一样,就是按位图整块写。也就是说内存里省下的那 99%,落盘时又回去了。要是你的痛点在磁盘/传输体积而不是常驻内存,这条得提前知道,别指望它顺手把文件也压小。它的好处在反过来那面:Ask_BHA 走 mmap,读回来是「打开就有」,不是「解压一遍」。
多类型混存要用 .bhax(9.12.0 起),照 README:
desc = BHAX_Descriptor("a.bhax")
desc.write_data(int_array.IntHybridArray([1, 2, 3]))
print(list(desc.read_data()))
我实测一个小坑:同一个 descriptor 连续 write_data 四次(int、float、嵌套 List、全 True 数组),文件只有 131 字节,但 read_data() 连着调四次,每次都返回最后一个写进去的对象(BoolHybridArr([True, True, True, True, True]))。想存多个对象,得像 README 的「多维」那段一样用 BHA_List 打包成一个再写。
最后交代边界,别被我上面那张表带跑
- 你要极致随机读吞吐、数据是稠密位图:
bitarray,别犹豫。 - 你要集合语义(存在性判断、交并差)、不需要
arr[i]:pyroaring那一档更对路。 - 你要
arr[i]语义 + 极稀疏(低于 3%)+ 常驻内存吃紧:这库是现在这几家里最省的,1% 密度 40 KB 对 122 KB。 - 你要 3% 到 95% 密度:它和
bitarray打平,别为「混合」两个字多付一次 Python 层读写的钱。 - 你的痛点在小数组(几千条):什么都别换,
list的 8 MB 那个数字是百万级的,几千条根本摸不到分配器地板,换库只是换麻烦。
我最后是这么落地的:在线标记(1%)用 bool-hybrid-array,已上报标记(60%)直接 bitarray,两个并存,各干各的活。巡检从四十秒降到六秒,进程内存从顶 swap 回到 1.2 G。这不是哪个库牛逼,是我终于按密度分了档。
浙公网安备 33010602011771号