先把像素这笔账算清楚那 800 多 KB,是编码器的工作台池子能复用啥,不能复用啥一个纯色方块,不值得逐个像素描复制有个坑:stride 不等于"宽度 × 4"并发跑起来,涨得比单线程更猛跑得快之前,先确认没画坏这本账,换个场景照样算
手机上那个小方框里的头像,放大看就是一堆色块。64×64,横竖各 64 格,一共 4096 个像素。
有人拿这么一张图去做了个体检,把"生成 + 压成 PNG"这一整套流程的内存账翻出来看,结果看到一个特别不像话的数字:每跑一次,就要在内存里分配 847 KB。
4096 个像素的东西,花掉 847 KB。这账怎么算都对不上——哪怕一个像素奢侈到用 4 个字节,也就 16 KB。中间那 800 多 KB 是从哪冒出来的?
一个像素占多少字节,取决于你用什么方式记它。
![]()
一个头像图案,通常只有前景色和背景色两种颜色。这种情况用调色板最划算:每个像素只存一个编号,4096 个像素 = 4096 字节 = 4 KB。改进之后,画布这一层确实只有 4 KB 了。
但那 847 KB 还在。因为画布大不大,和这次操作要分配多少内存,是两件事。
这里有个特别容易被混掉的区别:
- •一次操作分配多少(allocation):跑一遍,从堆上要了多少内存,用完就变成垃圾等回收;
- •同时占着多少(resident):进程此刻真实压在内存里的量。
前者的数字通常远大于后者,因为短命对象转手就进了垃圾回收器。对大图来说,这点开销被海量像素摊得看不见;可对 64×64 这种小图,它就成了主角。
打个比方:你去楼下买两根葱,每次都要叫一辆货车。葱不值钱,货车很贵——而且你买完就把货车扔了,下次再叫一辆。
PNG 不是一个"把像素原样倒出来"的格式。它要压缩,压缩就要干活:滑动窗口、哈希表、输出暂存区,一套下来需要一块不小的工作区。
标准库的思路很朴素:每次调编码函数,现场申请一块工作区,用完丢掉。大图时这很合理——几百 KB 的工作区对上几百万像素,占比可以忽略。但小图时角色就反过来了:
![]()
一张 4 KB 的画布,配一块几百 KB 的工作台,还要为每次调用重新搭一遍。这就是 847 KB 的来源。
官方给的解法也不神秘:编码器允许你插一个 BufferPool,工作区从池子里拿,用完还回去。
![]()
就这三行接线,别的没动。
这一步特别容易想歪,得说清楚:池子里躺的是编码器的临时工作区,不是你的图片。
- • 复用的是:编码过程中那块内部缓冲;
- • 不复用的是:最终输出的 PNG 字节、画布、你传进去的输出对象。
每次调用照样生成自己的图片,照样写自己的目标。池子里的东西只是编码器内部拿来当草稿纸的。
还有个必须记住的点:sync.Pool 不是永久缓存。垃圾回收器随时可能把它清空。所以代码的正确性绝不能建立在"下次一定还能拿到旧工作区"上——拿到了就少申请一次,拿不到就照常新建。它只适合这种"有更好、没有也能跑"的临时对象。
我用 Python 做了个等价的小实验(不是 Go 的实测数据,只验证趋势):3000 次操作,每次需要一块 64 KB 的工作区。
![]()
耗时差 8.5 倍。187 MB 与 64 KB 的对比更刺眼:这些内存本身不是问题,问题是它们每次都要被分配器记账、被 GC 扫一遍。
工作区解释了大部分差距,但还有一个浪费在画图那一层。
旧写法填一个矩形,是这样干的:
![]()
每个像素都要重算一次偏移,再写 4 个通道。逻辑没毛病,但对"整块同一个颜色"来说全是重复劳动:一行的第一个像素定下来,这一行后面几百个字节长得一模一样。
既然一样,就别一个个写,直接复制:
![]()
先写一个像素,然后 1→2→4→8 倍增复制,把第一行铺满;再拿这完整的一行,整块拷到其余各行。原来每个像素要做的一次偏移计算和四次赋值,变成几次连续内存复制。
同样用 Python 模拟 16×16 色块填 1000 次(逻辑等价,测的是"逐像素写"与"整行切片复制"的相对差距):
![]()
有意思的是,这一行 stride 差点埋了个雷。
大多数时候,一张图的行跨度(stride)正好等于一行像素的字节数,于是代码里把两者当一回事,也看不出问题。
但从大图上截下来一块子图时,这个等式就破了:子图只有 64 像素宽,行与行之间的真实间隔还是父图的 128 像素宽。你要按"子图宽 × 4"去算下一行起点,就会写到隔壁去。
我拿一块 128×128 的父图,截出左上角 64×64 的子图,往子图第 2 行填色,两种算法对比:
![]()
错的那一版,数据根本没进目标行,而是斜着跑到了上一行的后半段。图看着还在,只是颜色错了位——这种 bug 最难查,因为它不崩、不报错,只是"看起来有点怪"。
所以正确的测试不是"填完看看目标区域对不对",而是造一张父图、截个子图、填完再把父图其余像素全扫一遍,确认没被顺手改掉。
单线程的吞吐从约 6,300 张/秒 涨到约 30,000 张/秒,差不多 4.8 倍。8 个并发一起跑,从约 13,000 张/秒 涨到 155,000 张/秒,接近 12 倍。
这里没有偷偷加什么并行框架,也没有全局任务队列。就是正常的并发调用,每个协程各用各的图标、画布、输出对象,唯一共享的是那个线程安全的工作区池。
![]()
并发为什么涨得更多?因为旧路径下,多个协程会同时反复申请大块临时空间,分配和回收的压力叠在一起放大。工作区能复用之后,这类"用完就死"的对象不再一股脑推给 GC。
顺带说一句,8 并发要成立还有个前提:每次调用必须用自己的输出对象。池子只保证内部草稿纸可以共享,不保证你的 buffer 或文件句柄能共用。
池化最大的风险是"串味":上一份数据残留在工作区里,混进了这一次的输出。
验证方法很土但很硬:先用标准库原版编码一遍,留一份字节;再用池化版编同一张图,逐字节比对。
![]()
只跑一次不够。真正容易出问题的是并发,所以要再起 32 个协程,同时编码同一张只读的图标,各拿各的 buffer,结果必须和基准逐字节一致。这才算证明了池子里复用的只是临时空间,不会把上一次或另一个请求的内容带进来。
还有个反直觉的地方:大块复制不是永远更快。
如果色块本身只有一两个像素宽,"准备整行复制"的开销比直接循环写还贵。所以代码里保留了一条短路分支:
![]()
对应的基准用例也是特意加的:往 64×64 的图上画 64×64 的网格,每个格子只有 1 个像素。只测常见的 5×5、7×7 网格,很容易得出"复制一定更快"的错误结论,然后在极端场景里被打脸。
把这次的东西抽出来,其实是三个判断:
第一,看比例。有效载荷(4 KB 画布)和辅助开销(几百 KB 工作区)差了两个数量级,说明瓶颈不在"算得对不对",而在"准备得太贵"。
第二,看生命周期。工作区活不过一次调用,但每次调用都要一块同样大的——这种对象天生适合池化。反过来,如果对象本来就活得很久,池化毫无意义。
第三,看收益归谁。单次省下的几百 KB 不值钱,值钱的是它不再进 GC 的账本。所以并发越高、调用越密,收益越明显——这也是为什么 8 并发能涨 12 倍,而单线程只有 4.8 倍。
![]()
一个 64×64 的小图标,最后从 847 KB 降到 4.8 KB,吞吐翻了四五倍。真正被改掉的不是算法,而是"每次都要重新搭一次工作台"这个习惯。
你手上有没有那种"看着很小、跑起来很贵"的代码?评论区聊聊,说不定也是同一笔账。
特别声明:以上内容(如有图片或视频亦包括在内)为自媒体平台“网易号”用户上传并发布,本平台仅提供信息存储服务。
Notice: The content above (including the pictures and videos if any) is uploaded and posted by a user of NetEase Hao, which is a social media platform and only provides information storage services.