1. 问题背景与核心挑战
这个问题是典型的大数据处理面试题，考察候选人对海量数据处理、算法优化和系统设计的能力。我们面临的核心矛盾是：100GB的日志文件远超4GB内存容量，无法一次性加载到内存中处理。这种场景在实际业务中非常常见，比如电商平台的访问日志分析、CDN服务的流量统计等。
关键约束条件：
- 输入数据：100GB纯文本日志文件，每行一个IP地址（约150亿行）
- 内存限制：4GB可用内存
- 输出要求：访问频次最高的10个IP地址及其计数
注意：IP地址平均长度约15字节，原始数据直接加载需要约2.25TB内存，远超限制
2. 解决方案设计思路
2.1 分治法（MapReduce思想）
这是最可靠的解决方案，核心分为三个阶段：
- 分片处理：将大文件分割成内存可容纳的小文件
- 哈希统计：对每个小文件进行频率统计
- 归并聚合：合并所有小文件的统计结果
python复制# 伪代码框架
def process_large_file():
# 阶段1：文件分片
split_100gb_to_chunks()
# 阶段2：分布式统计
ip_counts = defaultdict(int)
for chunk in chunks:
count_ips_in_chunk(chunk, ip_counts)
# 阶段3：TopK筛选
find_top_10(ip_counts)
2.2 关键技术点解析
2.2.1 文件分片策略
采用哈希分片确保相同IP落到同一文件：
- 对每个IP计算hash值（如MD5）
- 取模运算确定分片编号：
hash(ip) % N - 将IP写入对应的分片文件
python复制import hashlib
def get_chunk_num(ip, total_chunks):
hash_val = int(hashlib.md5(ip.encode()).hexdigest(), 16)
return hash_val % total_chunks
技巧：分片数N建议设置为可用内存的70%（4GB内存约分200个20MB文件）
2.2.2 内存优化统计
使用高效数据结构进行计数：
- Python字典：默认选择但内存占用高
collections.defaultdict：比普通dict更高效- 手动实现的哈希表：极致优化但开发成本高
python复制from collections import defaultdict
def count_ips(file_path):
counts = defaultdict(int)
with open(file_path) as f:
for line in f:
ip = line.strip()
counts[ip] += 1
return counts
2.2.3 TopK算法选择
对比常见方案：
- 全排序后取前10：O(nlogn)时间复杂度，不可行
- 维护大小为10的小根堆：O(nlogk)最优解
python复制import heapq
def get_top_10(counts):
heap = []
for ip, count in counts.items():
if len(heap) < 10:
heapq.heappush(heap, (count, ip))
else:
if count > heap[0][0]:
heapq.heappushpop(heap, (count, ip))
return sorted(heap, reverse=True)
3. 完整实现方案
3.1 阶段一：文件预处理
python复制def split_large_file(input_file, chunk_size=20*1024*1024):
chunk_files = []
chunk_buffers = defaultdict(list)
with open(input_file) as f:
for line in f:
ip = line.strip()
chunk_num = get_chunk_num(ip, 200)
chunk_buffers[chunk_num].append(ip)
# 缓冲区达到阈值时写入磁盘
if sum(len(v) for v in chunk_buffers.values()) > 100000:
flush_buffers(chunk_buffers, chunk_files)
# 写入剩余数据
flush_buffers(chunk_buffers, chunk_files)
return chunk_files
def flush_buffers(buffers, chunk_files):
for chunk_num, ips in buffers.items():
filename = f"chunk_{chunk_num}.txt"
with open(filename, 'a') as f:
f.write('\n'.join(ips) + '\n')
if filename not in chunk_files:
chunk_files.append(filename)
buffers.clear()
3.2 阶段二：分布式统计
python复制from multiprocessing import Pool
def distributed_counting(chunk_files):
with Pool(processes=4) as pool:
results = pool.map(count_ips_in_chunk, chunk_files)
# 合并结果
total_counts = defaultdict(int)
for count in results:
for ip, cnt in count.items():
total_counts[ip] += cnt
return total_counts
def count_ips_in_chunk(chunk_file):
counts = defaultdict(int)
with open(chunk_file) as f:
for line in f:
ip = line.strip()
counts[ip] += 1
return counts
3.3 阶段三：TopK提取
python复制def get_final_top10(total_counts):
heap = []
for ip, count in total_counts.items():
if len(heap) < 10:
heapq.heappush(heap, (count, ip))
else:
if count > heap[0][0]:
heapq.heappushpop(heap, (count, ip))
return sorted(heap, reverse=True)
4. 优化技巧与注意事项
4.1 内存优化实践
-
使用生成器：避免一次性加载数据
python复制def read_ip_lines(file_path): with open(file_path) as f: for line in f: yield line.strip() -
选择高效数据结构：
defaultdict比普通dict节省约20%内存- 考虑使用
numpy数组存储IP的哈希值
-
控制分片大小：
- 每个分片应小于可用内存的1/3
- 监控实际内存使用：
import tracemalloc
4.2 性能优化技巧
-
并行处理：
python复制from concurrent.futures import ThreadPoolExecutor with ThreadPoolExecutor(max_workers=8) as executor: results = list(executor.map(process_chunk, chunk_files)) -
IO优化：
- 使用缓冲读写（默认已优化）
- 考虑SSD存储加速分片过程
-
算法优化：
- 两阶段堆排序：先取Top100再取Top10
- 布隆过滤器预处理异常IP
4.3 常见问题与解决方案
问题1：分片不均匀导致某些文件过大
- 解决方案：动态调整哈希函数，监控分片大小
python复制def balanced_hash(ip, max_chunk_size): chunk_num = 0 while True: hash_val = int(hashlib.md5(f"{ip}_{chunk_num}".encode()).hexdigest(), 16) target_file = f"chunk_{hash_val % 200}.txt" if os.path.getsize(target_file) < max_chunk_size: return hash_val % 200 chunk_num += 1
问题2：内存溢出风险
- 解决方案：实时监控内存使用
python复制import psutil def memory_safe_operation(): if psutil.virtual_memory().available < 500*1024*1024: # 500MB阈值 raise MemoryError("Insufficient memory")
问题3：IP格式异常
- 解决方案：增加校验逻辑
python复制import ipaddress def is_valid_ip(ip_str): try: ipaddress.ip_address(ip_str) return True except ValueError: return False
5. 扩展思考与进阶方案
5.1 分布式系统方案
当数据量进一步增大时（如PB级别），可考虑：
-
Hadoop/Spark方案：
scala复制val logs = spark.textFile("hdfs://logs/access.log") val topIPs = logs.map(_.trim) .map(ip => (ip, 1)) .reduceByKey(_ + _) .sortBy(_._2, false) .take(10) -
流式处理方案：
- Kafka + Flink实时统计
- 滑动窗口计算TopK
5.2 近似算法方案
当允许一定误差时：
-
Count-Min Sketch：概率数据结构
python复制from pybloom_live import CountMinSketch cms = CountMinSketch(width=1000, depth=5) for ip in ip_stream: cms.add(ip) -
HyperLogLog：基数估算
- 适合统计独立IP数
5.3 存储优化技巧
-
IP地址编码：
- IPv4转32位整数存储
- IPv6使用压缩编码
-
列式存储：
- 使用Parquet/ORC格式存储中间结果
-
增量处理：
python复制def incremental_processing(new_logs, existing_counts): new_counts = count_ips(new_logs) for ip, cnt in new_counts.items(): existing_counts[ip] += cnt return get_top_10(existing_counts)
在实际工程实践中，这个问题的解决方案需要根据具体场景灵活调整。我在处理某次电商大促日志时，就曾通过动态调整分片策略将处理时间从8小时缩短到40分钟。关键是要理解数据特征，合理利用内存和磁盘的平衡，以及选择适合的算法和数据结构。