大數據量文本文件高效解析方案代碼實現 測試環境 Python 3.6.2 Win 10 記憶體 8G，CPU I5 1.6 GHz 背景描述 這個作品來源於一個日誌解析工具的開發，這個開發過程中遇到的一個痛點，就是日誌文件多，日誌數據量大，解析耗時長。在這種情況下，尋思一種高效解析數據解析方案。 解決 ...
大數據量文本文件高效解析方案代碼實現
測試環境
Python 3.6.2
Win 10 記憶體 8G，CPU I5 1.6 GHz
背景描述
這個作品來源於一個日誌解析工具的開發，這個開發過程中遇到的一個痛點，就是日誌文件多，日誌數據量大，解析耗時長。在這種情況下，尋思一種高效解析數據解析方案。
解決方案描述
1、採用多線程讀取文件
2、採用按塊讀取文件替代按行讀取文件
由於日誌文件都是文本文件，需要讀取其中每一行進行解析，所以一開始會很自然想到採用按行讀取，後面發現合理配置下，按塊讀取，會比按行讀取更高效。
按塊讀取來的問題就是，可能導致完整的數據行分散在不同數據塊中，那怎麼解決這個問題呢？解答如下：
將數據塊按換行符\n切分得到日誌行列表，列表第一個元素可能是一個完整的日誌行，也可能是上一個數據塊末尾日誌行的組成部分，列表最後一個元素可能是不完整的日誌行（即下一個數據塊開頭日誌行的組成部分），也可能是空字元串(日誌塊中的日誌行數據全部是完整的)，根據這個規律，得出以下公式，通過該公式，可以得到一個新的數據塊，對該數據塊二次切分，可以得到數據完整的日誌行
上一個日誌塊首部日誌行 +\n + 尾部日誌行 + 下一個數據塊首部日誌行 + \n + 尾部日誌行 + ...
3、將數據解析操作拆分為可並行解析部分和不可並行解析部分
數據解析往往涉及一些不可並行的操作，比如數據求和，最值統計等，如果不進行拆分，並行解析時勢必需要添加互斥鎖，避免數據覆蓋，這樣就會大大降低執行的效率，特別是不可並行操作占比較大的情況下。
對數據解析操作進行拆分後，可並行解析操作部分不用加鎖。考慮到Python GIL的問題，不可並行解析部分替換為單進程解析。
4、採用多進程解析替代多線程解析
採用多進程解析替代多線程解析，可以避開Python GIL全局解釋鎖帶來的執行效率問題，從而提高解析效率。
5、採用隊列實現“協同”效果
引入隊列機制，實現一邊讀取日誌，一邊進行數據解析：
- 日誌讀取線程將日誌塊存儲到隊列，解析進程從隊列獲取已讀取日誌塊，執行可並行解析操作
- 並行解析操作進程將解析後的結果存儲到另一個隊列，另一個解析進程從隊列獲取數據，執行不可並行解析操作。
代碼實現
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re
import time
from datetime import datetime
from joblib import Parallel, delayed, parallel_backend
from collections import deque
from multiprocessing import cpu_count
import threading
class LogParser(object):
def __init__(self, chunk_size=1024*1024*10, process_num_for_log_parsing=cpu_count()):
self.log_unparsed_queue = deque() # 用於存儲未解析日誌
self.log_line_parsed_queue = deque() # 用於存儲已解析日誌行
self.is_all_files_read = False # 標識是否已讀取所有日誌文件
self.process_num_for_log_parsing = process_num_for_log_parsing # 併發解析日誌文件進程數
self.chunk_size = chunk_size # 每次讀取日誌的日誌塊大小
self.files_read_list = [] # 存放已讀取日誌文件
self.log_parsing_finished = False # 標識是否完成日誌解析
def read_in_chunks(self, filePath, chunk_size=1024*1024):
"""
惰性函數（生成器），用於逐塊讀取文件。
預設區塊大小：1M
"""
with open(filePath, 'r', encoding='utf-8') as f:
while True:
chunk_data = f.read(chunk_size)
if not chunk_data:
break
yield chunk_data
def read_log_file(self, logfile_path):
'''
讀取日誌文件
這裡假設日誌文件都是文本文件，按塊讀取後，可按換行符進行二次切分，以便獲取行日誌
'''
temp_list = [] # 二次切分後，頭，尾行日誌可能是不完整的，所以需要將日誌塊頭尾行日誌相連接，進行拼接
for chunk in self.read_in_chunks(logfile_path, self.chunk_size):
log_chunk = chunk.split('\n')
temp_list.extend([log_chunk[0], '\n'])
temp_list.append(log_chunk[-1])
self.log_unparsed_queue.append(log_chunk[1:-1])
self.log_unparsed_queue.append(''.join(temp_list).split('\n'))
self.files_read_list.remove(logfile_path)
def start_processes_for_log_parsing(self):
'''啟動日誌解析進程'''
with parallel_backend("multiprocessing", n_jobs=self.process_num_for_log_parsing):
Parallel(require='sharedmem')(delayed(self.parse_logs)() for i in range(self.process_num_for_log_parsing))
self.log_parsing_finished = True
def parse_logs(self):
'''解析日誌'''
method_url_re_pattern = re.compile('(HEAD|POST|GET)\s+([^\s]+?)\s+',re.DOTALL)
url_time_taken_extractor = re.compile('HTTP/1\.1.+\|(.+)\|\d+\|', re.DOTALL)
while self.log_unparsed_queue or self.files_read_list:
if not self.log_unparsed_queue:
continue
log_line_list = self.log_unparsed_queue.popleft()
for log_line in log_line_list:
#### do something with log_line
if not log_line.strip():
continue
res = method_url_re_pattern.findall(log_line)
if not res:
print('日誌未匹配到請求URL，已忽略：\n%s' % log_line)
continue
method = res[0][0]
url = res[0][1].split('?')[0] # 去掉了 ?及後面的url參數
# 提取耗時
res = url_time_taken_extractor.findall(log_line)
if res:
time_taken = float(res[0])
else:
print('未從日誌提取到請求耗時，已忽略日誌：\n%s' % log_line)
continue
# 存儲解析後的日誌信息
self.log_line_parsed_queue.append({'method': method,
'url': url,
'time_taken': time_taken,
})
def collect_statistics(self):
'''收集統計數據'''
def _collect_statistics():
while self.log_line_parsed_queue or not self.log_parsing_finished:
if not self.log_line_parsed_queue:
continue
log_info = self.log_line_parsed_queue.popleft()
# do something with log_info
with parallel_backend("multiprocessing", n_jobs=1):
Parallel()(delayed(_collect_statistics)() for i in range(1))
def run(self, file_path_list):
# 多線程讀取日誌文件
for file_path in file_path_list:
thread = threading.Thread(target=self.read_log_file,
name="read_log_file",
args=(file_path,))
thread.start()
self.files_read_list.append(file_path)
# 啟動日誌解析進程
thread = threading.Thread(target=self.start_processes_for_log_parsing, name="start_processes_for_log_parsing")
thread.start()
# 啟動日誌統計數據收集進程
thread = threading.Thread(target=self.collect_statistics, name="collect_statistics")
thread.start()
start = datetime.now()
while threading.active_count() > 1:
print('程式正在努力解析日誌...')
time.sleep(0.5)
end = datetime.now()
print('解析完成', 'start', start, 'end', end, '耗時', end - start)
if __name__ == "__main__":
log_parser = LogParser()
log_parser.run(['access.log', 'access2.log'])
註意：
需要合理的配置單次讀取文件數據塊的大小，不能過大，或者過小，否則都可能會導致數據讀取速度變慢。筆者實踐環境下，發現10M~15M每次是一個比較高效的配置。
作者：授客
微信/QQ：1033553122
全國軟體測試QQ交流群：7156436
Git地址：https://gitee.com/ishouke
友情提示：限於時間倉促，文中可能存在錯誤，歡迎指正、評論！
作者五行缺錢，如果覺得文章對您有幫助，請掃描下邊的二維碼打賞作者，金額隨意，您的支持將是我繼續創作的源動力，打賞後如有任何疑問，請聯繫我!!!
微信打賞
支付寶打賞 全國軟體測試交流QQ群
