边解压边删,删的到底是文件还是字节?
边解压边删,删的到底是文件还是字节?
一个 180 GB 的游戏包解开是 200 GB。用 WinRAR、7-Zip 或 unzip,你得准备 380 GB:因为在按下"删除压缩包"之前,压缩包和解压结果必须同时存在。几乎所有"磁盘不够怎么解压"的教程给出的方案都是同一句:先解压,再删包——这只把峰值推后了几分钟,没有把它降下来。
HatchZip 走的是另一条路:它从归档的尾部开始解压,每完成一批,就把归档截断到这批数据的起始偏移,回收的空间立刻供下一批使用。于是峰值不再约等于"包 + 输出",而是"输出 + 归档里最大的一块"。但这个描述里藏着一个必须回答的问题:它删掉的到底是"文件"还是"字节"? 这个区别决定了两条完全不同的实现路线,也决定了失败时你会失去什么。
一、"解压完再删"为什么必然失败
中文技术社区里关于这个需求的讨论,绝大多数停留在文件级操作。最常见的形态是批量脚本:遍历目录、对每个压缩包调用解压库、成功后 os.remove 或 File.delete。这类脚本的收益是"不用手动清理",而不是"省下空间"。
有几篇流传较广的帖子恰好暴露了文件级路线的两个死角:
其一是句柄未释放。有人用 Java 的 ZipFile 解压后删不掉原包,最终发现是没有调用 close()——文件级删除依赖"没有任何句柄持有它",这个条件在解压刚结束时恰恰最脆弱。
其二是峰值并未下降。批量脚本对单个包的处理仍是"完整解压 → 删除",磁盘曲线上每一批都是一个 2 倍的尖峰。只有当包本身很小、或者你在包与包之间串行处理时,尖峰才被摊平;一旦遇到单个 180 GB 的包,摊平无从谈起。
还有一条更激进的路线,被写成《流式读文件并删除已读部分》这类文章:把文件当作流读取,每次读一个 chunk,就把文件剩余的字节整体向前搬移 chunk 个字节,最后 truncate 掉尾巴。它确实实现了"读到哪里、删到哪里",代价是 O(n²) 的写入量:一个 180 GB 的包,前移的总字节数是它自身大小的平方量级。文章作者自己也承认"缺点是效率低"。这条路在原理上是对的,但它把"删头部"这件文件系统本来不支持的事,用用户态搬运硬顶了下来。
HatchZip 的做法介于两者之间,但选择了一个更省事的锚点:不在头部删,在尾部删。
二、为什么是尾部,以及 unit 是什么
docs/how-it-works.md 给出的理由非常干脆:所有操作系统和文件系统都支持把文件从尾部截短(ftruncate、SetEndOfFile);而删掉文件开头或中间的字节需要打洞(Linux 的 fallocate、Windows 的 FSCTL_SET_ZERO_DATA、macOS 的 F_PUNCHHOLE),FAT32 和 exFAT 根本不支持,各平台的行为也互不相同。
于是整个设计围绕一个概念展开——unit(单元):归档里一段能独立解码、并且当它包含的所有文件都已安全落盘后可以整段截掉的字节区间。
| 格式 | unit 的粒度 | 布局 |
|---|---|---|
| ZIP | 一个条目(本地头 + 数据) | 条目顺序排列,中央目录(索引)在最末尾 |
| 7z | 一个固实块,或非固实归档中的一个文件 | 32 字节签名头、按序的压缩块、末尾的头部(索引) |
| tar | 一个条目(含它前面的长名/pax 记录) | 头与数据记录按序排列,末尾是零块,没有索引 |
.tar.gz |
整个归档,但方向相反,从头部读起 | 一条 gzip 流包住整个 tar |
unit 按它在文件中的位置逆序处理。每批处理完,归档被截断到这批里起始偏移最小的那个 unit 的起点。这个动作对应 storage.rs 里的 set_len:
pub fn set_len(&self, len: u64) -> Result<()> {
for (i, p) in self.parts.iter().enumerate().rev() {
if p.start + p.len <= len { break; }
if i == 0 {
self.first.set_len(len)?; // 单文件:尾部截断
} else if p.start >= len {
fs::remove_file(&p.path)?; // 分卷:整卷删除
} else {
/* 跨在边界上的那一卷:单独截断 */
}
}
Ok(())
}
这段代码其实已经回答了标题的问题的一半:在单文件归档上,删的是字节区间;在分卷归档上,删的是整个卷文件。 分卷归档(game.7z.001、.002……)被 storage.rs 的 Storage 拼成一个逻辑文件,卷边界不需要任何特殊处理——一个 unit 可以横跨两卷,只要它 commit 了,后面那卷就被整个删除。所以"删文件"与"删字节"不是两种哲学,而是同一个动作在不同存储粒度上的表现。
选择从尾部回收的另一个后果是:7z 的固实块无法被部分回收。一个固实块只能从头解码,所以必须整块解完才能释放,这让"最大 unit"成为原地解压的主要空间成本。7-Zip 默认设置可能把整个归档压成一个块,此时这条路一点空间也省不下来——hatchzip check 会在动手之前把这件事说清楚。
三、一批的五个步骤,与两条不能越过的顺序
unit 是记账单位,真正执行时按批处理。每批走五步,顺序不能调换(engine.rs):
- 选批。从下一个未 commit 的 unit 开始,取若干 unit,使它们的解压后大小不超过"当前"空闲空间减去
--keep-free;一批最多 512 个 unit、2 GB。 - 并行解压。每个 unit 由一个工作线程解码,文件先写到
<name>.hatchzip-part,CRC 校验通过、大小与归档声明一致后才改名为真实文件名。 - 刷盘。整批强制落盘:Linux 上一次
syncfs,其他平台逐文件 fsync 并刷目录(macOS 用F_FULLFSYNC)。 - 提交。把新的
committed_len和本批产生的链接写入 journal。 - 截断。归档缩短到
committed_len,也就是本批最低 unit 的起点。
commit() 的代码把第 3 到第 5 步的顺序写得毫无余地:
platform::sync_batch(out).context("flushing extracted files to disk")?;
// ...
self.journal.committed_len = new_len;
self.journal.links.extend(links);
self.journal.resume = None; // 流式 unit 的断点与提交在同一次原子写里失效
self.journal.save(&self.paths)?;
crash_point("after-journal");
self.job.storage.set_len(new_len).context("shrinking the archive")?;
背后是一条规则,文档里用一句话概括:journal 绝不先于文件持久化而声称某个文件已完成,归档也绝不先于 journal 声称而截断。 这两句话把崩溃窗口切成三段,每一段都能恢复:解压/刷盘时崩溃,归档还完好,journal 不认这些文件,重来即可;提交时崩溃,要么旧 journal 要么新 journal,两种都能处理;截断时崩溃,journal 已经认账,下次运行发现归档比 committed_len 长,再截一次。
这里出现了字节级路线的第一个真实代价:"已提交"这个状态必须落在一个独立的小文件里。文件级方案没有这个负担,因为它的状态就是文件系统本身;而字节级方案一旦开始截断,归档就不再是它自己的完整描述,必须靠外部的 journal 记住"我删到哪了"。
四、索引先死:tail 侧存与"读成 0"的虚拟视图
ZIP 和 7z 都把索引放在文件末尾,而尾部正是截断第一个吃掉的东西。
HatchZip 的解法是:在截掉任何字节之前,先把"最后一个 unit 数据之后的所有内容"复制到 <archive>.hatchzip-tail,并把它的 CRC-32 记进 journal。之后所有解析都通过 storage::Reader 进行,这个 reader 在 tail 偏移之下读真实(已经被削短的)卷,在 tail 偏移之上读侧存副本,于是格式库看到的归档与原来一模一样。
已经截掉的区域呢?读成零。这个看似随手的处理其实很关键:ZIP 库找 EOCD 时是从尾部向前扫签名,而零永远不可能匹配签名;对 tar 来说,零块读起来就像归档的结束标记,于是"解析剩下的部分"自然得到"还没做的 unit"。不需要为"部分归档"写一套特殊的解析器,格式库自己就完成了这件事。
这套机制的边界也很清楚:tail 侧存只覆盖索引,不覆盖数据;一旦某个 unit 的数据被截掉,那些字节在归档里就真的不存在了。这正是字节级路线不可回退的部分。
五、当一个 unit 太大:把回收粒度打到 256 MiB 和 bit
按 unit 回收有一个硬伤:一个 30 GB 的单文件,在 commit 之前一个字节都释放不了,于是仍然需要 30 GB 的空闲空间才能开工。对"一个巨大镜像文件"这种最常见的大包场景,这等于没解决问题。
所以引擎有一条第二通道——streaming:当某个 unit 只包含一个文件、文件不小于两个 step(即 512 MiB)、且输出放不下时,它被单独流式处理。每写满 256 MiB 输出,就在下一个可重启点做一次"刷盘 → 记 journal → 打洞"。
打洞是从文件的数据起点打到断点所在的字节,文件长度不变,被释放的字节读作零。unit 前面的本地头或 tar 头永远不打洞,这样恢复时归档仍然能被解析。
断点必须精确到能重放解码器状态。Stored 数据可以从任意字节重启;deflate 只能从块边界重启,用的是 zlib examples/zran.c 那套技术,通过 zlib-rs 的 C API 暴露出来:inflatePrime、inflateSetDictionary、Z_BLOCK。块边界可能落在字节中间,所以 journal 里记录的是 bit 偏移:
fn restart_point(&self) -> Option<u64> {
// 128: 停在块结束之后。64: 那是最后一块,没有可重启的东西。
if self.done || self.data_type & 128 == 0 || self.data_type & 64 != 0 {
return None;
}
// 低位是 zlib 从输入里吃掉但还没用的位数,也就是它最后吃进的字节尾巴。
let held = (self.data_type & 63) as u64;
Some((self.fed_from + self.taken) * 8 - held)
}
除了 bit 偏移,deflate 还需要断点之前 32 KiB 的输出,因为后续的后向引用会回看到那里。这 32 KiB 不存进 journal,而是从已经 flush 的 part 文件末尾读回来——它本来就在磁盘上,而且是先刷盘、后记 journal 的,所以一定比断点更耐久。
save_point() 的四步顺序是整个流式路径的安全核心:
file.sync_all()?; // 1. 输出(含 32 KiB 窗口)落盘
self.journal.resume = Some(point);
self.journal.save(&self.paths)?; // 2. 断点变耐久
// 3. 解码重启点之前的归档字节至今仍可读
self.job.storage.punch(stream.data_start, point.bit / 8)?;
规则一句话:归档永远不会被打洞到最后一个耐久断点之后。 反过来,如果文件系统在探测时说支持打洞、实际调用却返回不支持(FAT32、exFAT,或某些被克隆的快照场景),运行会继续,只是不再中途释放空间——正确性不受影响,空间收益消失。
证据链也在这条路径上最密。streaming.rs 会在每个断点的三个步骤分别 kill 进程(stream-after-sync、stream-after-journal、stream-after-punch),然后恢复并逐字节比对;resumable.rs 的单元测试则从每一个报告的块边界重启 deflate,level 6 和 9 都要求至少有 10 个断点,并且必须存在落在字节内部的断点。
六、最坏情况:tar.gz 只能从前往后
gzip 是一条只能从头解码的流,没有"从尾部开始"这个选项。HatchZip 对它不做 unit 拆分,整个归档就是一个 unit,从前往后读,用打洞释放解码器背后的压缩字节,断点同样是 256 MiB 一个。
它比其他格式多付一笔开销:动手之前必须把整条流完整解码一次(targz::open),用来列出条目、校验每个 gzip 成员的 CRC-32 和 ISIZE、并测量空间检查需要的"输出超出压缩字节的最大领先量"。如果归档损坏,它在没有改动任何东西的状态下被拒绝。恢复时无法从开头重放(那些字节可能已经没了),所以恢复点只能用当时的断点重新走一遍。
Profile 结构体记录的正是空间检查要用的两个量:
pub struct Profile {
pub files: u64, // 普通文件,按写入时占的 4 KiB 块计
pub links: u64, // 链接,按目标的尺寸计(FAT32 上会退化成复制)
pub lead: i128, // 已写文件超出已消费压缩字节的最大值
pub gap: u64, // 相邻两个断点之间的最大文件输出
}
lead.max(0) + stream_step + gap + 读缓冲 + 两端各一个 granule,这就是流式 tar 在最坏时刻需要的空闲空间。README 里那组实测数据可以对照:820 MiB 的 tmpfs 上放一个 385.9 MB 的 .tar.gz(501.1 MB、2016 个条目),空闲 473.9 MB,GNU tar -xzf 空间不足;hatchzip check 说需要 400.2 MB,实际运行时每 10 ms 采样的最低空闲是 111.8 MB,峰值占用 362.1 MB,1.0 秒完成,每个文件的 SHA-256 都对得上。
而如果这个 tar.gz 放在 FAT32 或 exFAT 上,打洞不可用:解压照样能跑、照样能断点续传,但在结束之前一个字节都不释放,check 会明确告知需要"归档 + 全部文件"的空间。这是字节级路线在能力不足的文件系统上退化成文件级路线的样子。
七、两条路线的失败模式差异
这是本文真正想讨论的部分。两条路线不是"慢"与"快"的差别,而是失败时你失去什么的差别。
| 文件级删除(解压完再删) | 字节级回收(边解压边删) | |
|---|---|---|
| 空间峰值 | 归档 + 输出 | 输出 + 最大可回收单元 |
| 中断后 | 归档完整,输出半份,可重来或换工具 | 归档已部分消失,必须靠 journal 才能继续 |
| 损坏发现时机 | 解压结束时才知道 | 每个文件 CRC 边解边验,损坏点即停 |
| 最坏结果 | 空间不足,什么都没丢 | 若下载本身损坏,损坏点之前已解出、归档已部分消失 |
| 索引 | 无需额外保存 | 必须侧存 tail 与 journal,且两者不能丢 |
| 回退能力 | 删除可撤销(回收站/重下) | 已被截断的字节无法重建,只能恢复"剩下的部分" |
第一行的收益是数量级的,但后面四行是必须付的账。
文件级的失败是"空间不释放",字节级的失败是"数据不可回退"。 前者的典型现场是:unzip 在第 6 个文件时磁盘写满,你得到一个不满意的输出目录和一个完好的压缩包,删掉输出重来即可。后者的现场是:跑到一半断电,归档只剩前 committed_len 字节,索引不在里面,唯一的线索是旁边两个小文件。
HatchZip 用三层机制把这个不可回退窗口压到最小:
第一层,顺序约束。 前面说的"journal 先于截断、文件先于 journal"。文件只有在持久化之后才会被 journal 认账,归档只有在 journal 认账之后才会被截断。任何时刻崩溃,磁盘上要么有文件,要么有它的字节,不会两者都没有。
第二层,restore。 当你决定放弃这次解压时,hatchzip restore game.zip 会把剩下的一半变回一个普通归档:它把新索引追加在 committed_len 处,只覆盖必须改的字节(对 7z 来说就是那个指向新头部的签名头),然后用与解压相同的解析器重新打开、校验条目列表是否完全一致。因为 committed_len 以下的内容一个字节都没动,它需要的空闲空间只是新索引的大小。已解出的文件留在输出目录里不动。
第三层,明确的拒绝。 如果 journal 里存在流式断点,说明有些归档字节可能已经被打洞释放,restore 会拒绝并建议继续解压:
if let Some(r) = &journal.resume {
bail!("{} cannot be restored: a large entry was being extracted, and the archive space \
of its first {} may already be released. Run extract to complete the extraction instead",
primary.display(), engine::human(r.written));
}
这是一个诚实的边界声明:能恢复的是"剩下的归档",不是"删掉的字节"。 打洞之后连长度都没变的部分都无法重建,因为那些零已经不是原来的数据。
八、空间检查:先算清楚,再动手
字节级路线要成立,必须能在动手之前回答"够不够"。HatchZip 的做法是把整个解压过程按 unit 重放一遍,累加每一步新增的(unit 的文件,每个向上取整到 4 KiB 块)与释放的(unit 在归档中占的区间),再加上启动时写出的 tail。这个运行总量的最高点,就是需要的空闲空间。
pub fn space_needed(&self, fresh: bool, reclaims: bool) -> (u64, i128) {
let tail = (self.storage.original_len() - self.tail_start) as i128;
let mut extra: i128 = if fresh { tail } else { 0 };
let mut peak = extra;
for (i, u) in self.units.iter().enumerate() {
/* 固实块 / 流式 unit / 普通 unit 三种计价方式 */
}
// 第一个 unit 之前的内容(自解压 stub、7z 签名头)在最后删除
(peak.max(0) as u64, extra)
}
session.rs 里的判定只有一行,但含两个容易被忽略的输入:free,以及 reclaims——输出目录是否与归档在同一个文件系统上。
let fits = free >= needed + keep_free;
如果输出在另一块盘上,释放归档对输出盘毫无帮助,检查会明说,并且不会把"回收"计入账本。如果没有打洞能力,tar.gz 会被标记为 archive_kept_whole,需要的空间直接变成"归档 + 全部文件"。
README 里那张对照表是这套计价最直观的验证:220 MiB 的 tmpfs、约 50 MB 空闲,装同样的 200 MB 游戏数据(21 个文件)。
| 归档 | unzip / 7-Zip |
HatchZip |
|---|---|---|
| ZIP,180 MB | unzip 在第 6 个文件空间不足 |
完成,逐字节一致 |
7z(-ms=20m,10 个固实块) |
需要 380 MB | 0.64 秒完成,逐字节一致 |
| 7z 切成 5 卷、每卷 40 MB | 需要 380 MB | 完成;每卷解完即删,峰值 210 MB |
| tar,200 MB | 需要 400 MB | 0.12 秒完成,逐字节一致 |
| 7z 默认设置(1 个固实块) | 需要 380 MB | 动手前拒绝:固实块解完才能释放,需要 200 MB 空闲 |
最后一行是这套设计最诚实的失败:它没有作弊,直接告诉你"这个包我救不了"。而第三行是"删的到底是文件还是字节"的最好注脚——分卷归档上,HatchZip 删的确实是文件,一卷一个;等所有内容都从这卷里出来,它就消失了。
九、这条路的适用边界
把上面的机制串起来,可以清楚列出什么时候它有用、什么时候它不该被用:
- 单个巨型固实 7z 块:帮不上忙。7-Zip 的默认设置很容易产生这种包,
check会拒绝并提示用更小的固实块重新打包。 - FAT32 / exFAT 上的
.tar.gz:能解压、能续传,但空间不释放,等于退化为常规工具。 - 输出到另一块盘:归档侧的回收对输出侧无效,检查会指出这一点。
- btrfs / APFS 快照:包含归档的快照不删,被释放的空间不会被真正交还。
- 下载本身可能损坏:默认行为是边解边验 CRC,损坏点即停;但损坏点之前的文件已经解出、归档已经部分消失。如果这个包无法重新下载,用
--verify-first先整包读一遍校验和,再开始删。 - 输出目录非空:直接拒绝。这是为了在恢复时能安全删除"上次写到一半、从未 commit"的文件——如果目录本来是空的,那些路径上的东西就一定是自己写的。
这些边界本身也说明了一件事:字节级回收不是在文件级方案上加个开关,而是一整套围绕"耐久顺序"重建的机制。它换来的东西很具体——180 GB 的包不再需要 380 GB 的磁盘,而只需要略多于 200 GB。
十、删的是字节,文件只是记账单位
回到标题。
"解压完再删"删的是文件:一个 inode、一个目录项,原子、不可分割,所以只能等整个归档都处理完才敢动手,峰值因此无法下降。
HatchZip 删的是字节区间:truncate 削掉尾部,punch 挖掉中段;在分卷归档上,回收的表现才退化为删除整个卷文件。unit、批、committed_len 都只是给"一段字节"和"一批文件"之间建立对应关系的记账工具。真正被回收的永远是字节,文件是它要保护的对象。
而这个选择立刻带来第二重代价:字节可以被削掉,就意味着它可以被削得太多。所以整篇文章里出现最多的不是压缩算法,而是顺序——先刷盘、再写 journal、最后截断;先探测打洞是否真的释放了空间,再相信它;先在动手前重放一遍算出峰值,再说"够"或"不够"。
一句话概括这套设计的取舍:它把"空间不释放"的失败,换成了"数据不可回退"的风险,然后用 journal、耐久顺序和 restore 把这个风险限制在"已经安全落盘的那部分数据"之内。 你得到的不是免费的午餐,而是一笔算得很清楚的账。
