Python大日志文件过滤：逐行、mmap与多进程对

脚本专家

在处理 GB 级应用日志时，常见需求是从中快速提取 ERROR 或特定 trace_id。原文以 2GB 左右日志为案例，对比 Python 的逐行流式读取、mmap 内存映射和多进程分块并行三种过滤方案，并给出实测耗时与内存数据。下面按代码实现、边界处理和性能结果重新整理。

一、逐行流式读取：baseline

最直接的写法是 open() 配合 for line in f，逐行扫描，把包含关键字的行写入目标文件。逻辑简单可靠，适合日志规模不大或对速度不敏感的场景。示例：

2. def filter_stream(log_path, keyword, out_path):
3.     with open(log_path, 'r', encoding='utf-8', errors='ignore') as fin, open(out_path, 'w') as fout:
4.         for line in fin:
5.             if keyword in line:
6.                 fout.write(line)

复制代码

每次迭代都会在 Python 层做字符串解码和关键字匹配。原文实测 2GB 日志耗时约 45 秒，内存占用约 20MB，主要来自缓冲。问题是文件越大，Python 层循环和匹配开销越明显。

二、mmap + 内存视图：减少系统调用和 Python 循环

优化思路是用 mmap 把文件映射到虚拟内存，避免频繁 read 系统调用；再通过 bytes.find() 定位关键字，并配合 memoryview 切片输出匹配行。核心示例：

2. import mmap
4. def filter_mmap(log_path, keyword, out_path):
5.     keyword_b = keyword.encode()
6.     with open(log_path, 'rb') as f, mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm, open(out_path, 'wb') as fout:
7.         start = 0
8.         while True:
9.             idx = mm.find(keyword_b, start)
10.             if idx == -1:
11.                 break
12.             # 找到行首和行尾
13.             line_start = mm.rfind(b'\n', 0, idx) + 1
14.             line_end = mm.find(b'\n', idx)
15.             if line_end == -1:
16.                 line_end = mm.size()
17.             fout.write(mm[line_start:line_end])
18.             fout.write(b'\n')
19.             start = line_end + 1

复制代码

关键点是 mmap.find 由 C 实现，速度远高于 Python 层循环。需要注意边界情况，例如关键字跨行、最后一行没有换行符等。原文实测 2GB 日志耗时 12.8 秒，内存 45MB，内存开销主要来自映射。

三、多进程分块并行：利用多核的终极优化

当单机多核时，可以按字节偏移把文件均分成 N 块，每个进程独立处理一块，最后合并结果。为了避免切块时截断行，需要查找块首的换行符进行对齐。原文给出简化示例：

2. import os, multiprocessing as mp
4. def worker(chunk_path, start, end, keyword, out_path):
5.     with open(chunk_path, 'rb') as f:
6.         f.seek(start)
7.         # 对齐到行首（略）
8.         data = f.read(end - start)
9.         lines = data.split(b'\n')
10.         matched = [line for line in lines if keyword in line]
11.         with open(out_path, 'ab') as fout:
12.             for line in matched:
13.                 fout.write(line + b'\n')
15. def parallel_filter(log_path, keyword, num_workers=4):
16.     size = os.path.getsize(log_path)
17.     chunk_size = size // num_workers
18.     # 创建任务列表（略）

复制代码

实际应用时要处理块边界，可用 seek 定位到下一个换行符。并行方案在 8 核机器上可把 2GB 日志处理时间从 45 秒降到 8 秒。原文还给出并行 mmap（4 进程）耗时 8.1 秒、内存峰值 180MB 的数据。进程数需要控制，否则可能耗尽内存。

四、性能验证与方案选择

原文测试环境为 8 核 CPU、16GB 内存、2.1GB 日志、约 1200 万行。对比结果如下：

流式读取：45.2 秒，内存 18MB
mmap 方案：12.8 秒，内存 45MB（映射开销）
并行 mmap（4 进程）：8.1 秒，内存 180MB（峰值）

验证方法：使用 time 命令测耗时，用 /usr/bin/time -v 查看最大常驻内存。选择建议：单机日志过滤优先考虑 mmap，性价比最高；如果追求极致速度且内存充足，可以上多进程；最终应结合日志大小和机器规格决定。并行时尤其要限制进程数，避免内存耗尽。

热心网友1

这套整理挺实用的，三种方案的取舍讲得很清楚。逐行流式作为 baseline 胜在简单稳，内存也低，但 2GB 要 45 秒确实慢。mmap 把查找放到 C 层，12.8 秒这个提升很直观，不过关键字跨行、最后一行没换行这些边界确实要处理好，否则容易漏行或多切。多进程并行把 2GB 压到 8 秒左右，多核收益明显，但 180MB 峰值和分块对齐、合并输出这些细节也不能忽略，进程数一定得按机器内存压住。我的感觉是，日常单机过滤优先 mmap 最平衡，追求极致再上多进程；日志特别大或内存紧张时，流式依旧是最稳的兜底。

热心网友3

感谢整理，三种方案的取舍讲得很清楚。逐行流式虽然慢，但代码简单、内存低，适合先跑通和做结果对照；mmap 的核心优势确实是用 C 层的 find 和切片避开 Python 逐行循环，12.8 秒这个提升很直观；多进程把 2GB 日志压到 8 秒左右，也符合 8 核机器的预期。 几点我会额外注意：mmap 输出最后一行时会补换行，若要求与原日志完全一致得单独判断；关键字如果可能跨行，按行边界切会漏掉或截断。多进程共用 ab 追加同一个输出文件，行很长时写入可能交错，最好每个 worker 写临时文件再按块顺序合并，或者让主进程统一落盘。并行进程数也别只看核数，像你给的 4 进程峰值 180MB，8 进程内存会明显上去，得留余量。 整体上，单机偶尔过滤我会优先 mmap，要求稳或环境受限就用流式，追求速度再上多进程。感谢分享实测数据。

热心网友3

楼主整理得很系统，三种方案从代码、边界处理到实测数据都覆盖到了。逐行流式作为 baseline 简单可靠，mmap 用 C 层 find 减少 Python 层循环这个点很关键，多进程分块并行把多核利用起来也确实快。尤其是块边界对齐、最后一行没有换行符这些细节，实际写的时候很容易忽略。性能数据很有参考价值：2GB 日志流式 45.2 秒、mmap 12.8 秒、4 进程并行 mmap 8.1 秒，内存占用也标得清楚，最后的方案选择建议很实用。准备拿自己的日志按这个思路对比一下，感谢分享。