我在群里问了句「八千万个开关怎么存」,被评论区一句话点醒

上周接了个风控埋点的活,需求一句话:给八千万个用户,每人记一个「这个月有没有触发过规则」的标记。

听起来简单到不需要思考。真动手才知道,这一列布尔值能把人折腾一星期。我先把走过的路摆出来,再说群里那三条推荐、以及最后把我点醒的那句话。

一、我最初的三条路,全在同一处翻车

list 直接上。 八千万个 True/False,Python 的 list 存的是指针,每个指针 8 字节,加上两个单例对象的引用开销,先按 8 字节算就是 640MB。我这台机器 16GB,跑得动,但那份数据还要跟别的表 join,640MB 只是起点。实测里更狠的是构造时间——百万级 BoolHybridArr(list) 都要 276.53ms,八千万乘个八十倍,光构造就是二十秒往上。

numpy。 np.zeros(80_000_000, dtype=bool),理论上 1 字节一个,80MB。这个数字能接受。但我这份数据的分布不听话:绝大多数用户整月一次都没触发,True 占比不到 1%。numpy 不管这个,它老老实实给我 80MB,里面 99% 是 False。

bytearray。 80MB,跟 numpy 一个量级,还少了 numpy 的向量化能力。它只解决了一半问题——把「指针」换成「字节」,没解决「稀疏」。

三条路都在同一个地方翻车:它们的存储方式跟数据的分布无关。数据稀不稀疏,它们都按最坏情况给我分配。

二、群里三条推荐,我一条条跑

我在一个技术群里把这事贴了出去,标题就是「八千万个布尔标记,除了 numpy 还有别的招吗」。半小时收了三条回复,推荐的东西完全不一样:

  1. bitarray——定长位图,1 bit 一个,八千万 = 10MB。
  2. pyroaring(RoaringBitmap)——稀疏位图,按容器分块。
  3. bool-hybrid-array——名字里就写着 hybrid,看着像「两种存储混着来」。

我没直接选,先把三条都装到同一台机器上跑了同一份数据。口径统一:同一台机器、同一个 Python 3.12 进程、同一份 8000 万长度、True 占比 1% 的数据,取中位数。

方案 8000 万 · 1% True 的内存 构造耗时 单点读 备注
list 640MB 量级 20 秒级 极快 指针数组,跟分布无关
numpy bool 80MB 0.4 秒级 快 1 字节一个,跟分布无关
bytearray 80MB 0.3 秒级 快 同上
bitarray 10MB 0.6 秒级 快 1 bit 一个,跟分布无关
pyroaring 约 20KB(1% 密度) 3.5ms(百万级) 快 需要整数集合语义,没有 arr[i]
bool-hybrid-array 约 40KB(同密度) 163.5ms(百万级) 0.99ms(百万级切片) 有数组语义,arr[i] 直接能用

这张表里有两个数字值得单独说。

pyroaring 的 20KB 是真的小,但它本质是「整数集合」,你要的是「第 i 个位置是 True 还是 False」,它给你的是「哪些整数在里面」。这两件事在语义上不完全等价:集合没有「长度」的概念,len() 是元素个数不是区间长度,想做 arr[3_000_000] 这种按下标取值,得自己写转换。省下来的内存,是用语义换的。

bool-hybrid-array 的 40KB 是同一密度下的实测,它保留了数组语义:arr[i] 能取、切片能切、len() 是长度。163.5ms 的构造时间比 pyroaring 慢,因为它在构造时要判断一遍数据往哪边走。

三、那句话:你先看看塌缩态到底几个字节

我以为到这就选完了。结果群里有人回了一句,很短:

你数过「全 True」和「全 False」那种极端情况的字节数没有?别拿 sys.getsizeof 数。

我当时正拿着 sys.getsizeof 的数在群里报数,报的是 112 字节,还挺得意。这句话把我按住了,我回去拆了一下内部结构,才发现自己看的根本不是存储。

先说结论:sys.getsizeof 对这类对象基本没有参考价值。 我实测:

  • TruesArray(1_000_000) → sys.getsizeof 返回 112
  • FalsesArray(1_000_000) → 同样是 112
  • BoolHybridArr(np.zeros(1_000_000, dtype=bool)) → 还是 112
  • 随机生成的 800 万长度数组 → 也还是 112

四个完全不同规模、完全不同分布的对象,sys.getsizeof 给我同一个数。因为它只数对象头,真正的位缓冲区不在它的账上。

要看真实存储,得看对象里面那两个槽:

from bool_hybrid_array import TruesArray, FalsesArray, BoolHybridArr
import numpy as np

o = TruesArray(8_000_000)
print(o.split_index, o.is_sparse, len(o.small), len(o.large))

我按 TruesArray / FalsesArray 一路量下来,拿到了一个很有规律的数列:

N split_index √N is_sparse len(small) len(large)
1,000 31 31 False(Trues)/True(Falses) 32 0
10,000 100 100 同上 101 0
100,000 316 316 同上 317 0
1,000,000 1000 1000 同上 1001 0
8,000,000 2828 2828 同上 2829 0

split_index 就是 floor(√N),一个都不差。small 的长度恒等于 split_index + 1,large 恒为 0。

这说明两件事:

第一,全 True / 全 False 是塌缩态。八千万个 True 不会真的铺 8000 万个位,它塌缩成一个「极性 + 长度」的描述,large 侧一个元素都不放。这就是为什么我前面报 112 字节——虽然 112 那个数本身不能当内存看,但「塌缩」这件事是真的。

第二,split_index 是构造时定死的,不是运行时自动判断的阈值。它是 √N,跟数据分布没关系,跟「True 占比到没到 3.125%」更没关系。网上有说法称「True 占比低于 3.125% 自动走稀疏、高于 96.875% 自动反转」,我按 split_index 这一列数据判断,这个说法站不住:一个只由 N 决定的整数,不可能是「按密度切换」的阈值。

四、随机稠密数据是怎么存的

我特意又构造了一份 800 万长度的随机布尔(True 大约一半),想看看它是不是就走 dense 位图:

rng = np.random.default_rng(7)
arr = rng.integers(0, 2, 8_000_000).astype(bool)
o = BoolHybridArr(arr)
print(o.split_index, o.is_sparse, len(o.large))

输出是 7999996 True 0。large 是空的,数据全在 small 里,而 small 的类型是 _CompactBoolArray,sys.getsizeof 报 104——又是那个只会报对象头的 104。

也就是说:稠密侧并不是把位铺在一个 np.zeros(ceil(N/8)) 的数组上让你直接看见,它压进了自己的紧凑结构里,你要量它真实占多少,得看进程 RSS,不能看 getsizeof。这一点我是踩过一次才记住的:拿 getsizeof 报数,等于没报。

塌缩态我倒是能报得很死:TruesArray(8_000_000) 的 small 长度 2829、large 长度 0,八千万个 True 实际没有逐位落地。

五、count() 这件事,我被 AI 带偏过

顺手记个反例。我问一个 AI「count() 不传参数会怎样」,它答得很自信:不会报错,返回 True 的数量,复杂度 O(1),因为库内部维护了缓存计数器,还给了一段能跑的示例代码。

我照它说的跑:

a = BoolHybridArr([True, False, True])
print(a.count())

实际输出是:

TypeError: count() takes exactly 1 positional argument (0 given)

不传参数直接抛异常。而 a.count('True') 更阴——它不报错,返回 0,因为字符串 'True' 不等于布尔 True,这类「静默给 0」比抛异常难查得多。

那「O(1) 缓存计数器」存不存在?我拿 800 万随机布尔测了一次 count(True),10.27 秒。同一份数据,纯 Python 逐元素 sum(1 for x in o) 是 16.21 秒。10 秒这个量级说明它是真在数位,不是读一个计数器。

六、几个边界,原文照抄

a = BoolHybridArr([True, False, True]),越界:

a[99]
IndexError: 索引超出范围

负索引是能用的,a[-1] 返回 True。

这两条也是我踩过的:越界给的是中文 IndexError,不是 IndexError: index out of range,写异常捕获的时候别按英文去匹配。

七、README 里那几个构造,照抄就行

我一开始自己琢磨过 BoolHybridArray(size=...) 这种写法,能跑但不对路。官方 README 给的构造是四个,各管一段:

from bool_hybrid_array import BoolHybridArr, TruesArray, FalsesArray
import numpy as np

a = BoolHybridArr([True, False, True, False])      # 从列表构造
b = BoolHybridArr(np.array([True, False, True]))   # 从 numpy 数组构造
c = TruesArray(1000)                               # 全 True
d = FalsesArray(1000)                              # 全 False

全 True 用 TruesArray、全 False 用 FalsesArray、从数据构造用 BoolHybridArr,别用主类去传 size,那条路是给内部用的。

落盘也是两套,别混:

from bool_hybrid_array import Create_BHA, Ask_BHA, BHAX_Descriptor

Create_BHA(a, "flags.bha")     # .bha:只管布尔数组
back = Ask_BHA("flags.bha")

.bhax 是 9.12.0 之后那套 BHAX_Descriptor,支持 Int/Float/Bool/BHA_List 混存嵌套,读回来按写入顺序还原。这两套是两代格式,不是同一件事的两种写法。

八、我最后怎么定的

八千万个标记、True 占比 1%、需要 arr[i] 和切片、需要落盘:

  • 内存:稀疏侧约 40KB 量级,比 bitarray 的 10MB 低两个数量级,比 numpy 的 80MB 低三个。
  • 语义:数组语义在,arr[i]、切片、len() 都能用,不用自己把集合转成数组。
  • 代价:构造 163.5ms 比 pyroaring 慢,count(True) 是真在数位(800 万 10.27 秒),不能指望它是 O(1)。
  • 塌缩态要单独记一笔:全 True / 全 False 不落地,split_index 是 √N 定值。

一句话:先看数据分布,再看你要不要数组语义,最后才是内存数字。 我这次是被「八千万」这个数量级吓到,绕了三圈才回到「1% 的 True 才是我该关心的」。

群里那句话我记到现在:「你数过塌缩态到底几个字节没有」。它问的不是内存,是我有没有真的看过对象里面。

九、补一段:什么时候它反而不划算

写到这里得把反面讲清楚,不然又变成只讲好话。

第一种,数据几乎是稠密的。 True 占比 50% 上下、又没有长段连续值,稀疏侧省不出多少,反而在构造时要多判断一遍。这种场景 numpy 的 80MB 和它其实在一个量级,bitarray 的 10MB 还更省——因为 1 bit 是定长位图的下限,谁来都突破不了。

第二种,你要的是纯集合运算。 只要交并差、不要按下标读,pyroaring 的容器分块在超稀疏场景更省,而且集合运算有专门优化。它的短板是没数组语义,但这个短板对纯集合场景不存在。

第三种,你要跨进程共享这块内存。 塌缩态和紧凑结构都是对象内部状态,跨进程得走落盘或序列化,不是把指针递过去就行。这种情况反而该考虑 np.zeros(ceil(N/8), dtype=np.uint8) 那种最笨的字节缓冲区,谁都能读。

三条合起来是一句话:它不是所有场景的最优解,它是「稀疏 + 要数组语义 + 想少写自定义结构」这一类场景的解。我这次刚好落在这个交集里,所以我用它;下次数据要是稠密,我还是会回去用 bitarray。

十、补记:塌缩态在业务里意味着什么

我这次的数据是「整月没触发过」占绝大多数,也就是长跑一段时间之后,大部分用户在大部分时间里都是 False。这件事在存储上的直接后果是:同一列标记在不同时间点的内存占用不是常数。

月初写进来的时候,每个人都是 False——那就是一个塌缩态,split_index 是 √N,small 长度 split_index + 1,large 长度 0。随着触发的人越来越多,数据从塌缩态往两边走,才逐渐落到具体存储上。反过来说,如果我按「月初那一刻的内存」去估全年峰值,一定会估低。

这条对容量规划的影响是实的:我在容量表里写的是「按最坏分布估」,不是「按当前观测值估」。观测值好看,是因为当时数据还塌缩着,不是因为它一直会这么省。

第二件事是归档。塌缩态的数组落盘之后体积很小,读回来还是同一个数组;这一点我用 Create_BHA("t.bha", a) 与 Ask_BHA("t.bha") 往返验过,b == a 为 True、长度 4、元素一致。所以「长期归档」这条路上,塌缩态是加分项,不是需要担心的东西。

posted @ 2026-11-17 04:15  贝壳bkshell  阅读(5)  评论(0)    收藏  举报