高效日誌系统设计挑战

大家好，我最近在研究 Python 的多执行绪与多处理程序设计，尤其是涉及 高效处理共享资源 的问题时，发现了一些值得深挖的挑战，想和大家讨论一下。

特别是我在设计一个 高效的日誌系统 时，面临了多执行绪写入档案的问题，想请教大家的经验与见解。这里不是单纯探讨如何用锁（threading.Lock）来解决竞态条件，而是希望能讨论一些更高阶的模式，比如如何设计一个 无锁（lock-free） 的系统，或者如何避免共享资源导致的性能瓶颈。

场景：多执行绪日誌记录系统

假设我们需要设计一个日誌系统，允许多个执行绪同时记录日誌，并将结果写入同一个档案中。问题在于：

• 使用锁（如 threading.Lock）来同步日誌写入，虽然可以确保资料一致性，但会大幅降低写入效能，特别是在高併发的场景下。
• 如果不用锁，则可能出现资料覆盖、日誌内容混乱的情况。
• 日誌写入本身可能是系统的性能瓶颈，是否应该考虑将日誌先存入记忆体伫列（in-memory queue），然后用一个单独的执行绪统一写入档案？
• 如果採用这种方式，又该如何设计来避免记忆体伫列溢出？
• 在这种架构下，是否会出现新的性能瓶颈？

测试程式码

下面是我尝试写的一段模拟程式码，用来测试多执行绪同时写入档案的情况。程式中启动了 3 个执行绪，分别模拟不同执行绪写入相同档案。

import threading
import time

# 模拟多执行绪写入日誌
def log_to_file(filename, thread_id):
with open(filename, "a") as file:
for i in range(5):
file.write(f"Thread {thread_id} - Log entry {i}\\n")
time.sleep(0.1) # 模拟写入延迟

threads = []
filename = "logfile.txt"

# 启动多个执行绪
for i in range(3):
t = threading.Thread(target=log_to_file, args=(filename, i))
threads.append(t)
t.start()

for t in threads:
t.join()

print("日誌记录完成。请检查档案内容。")

测试结果

执行上面的程式码后，我发现以下问题：

日誌顺序混乱

不同执行绪的日誌输出顺序并不稳定，有时候会出现一个执行绪的日誌被其他执行绪插入，导致内容混乱。

效能瓶颈

如果为了解决混乱的问题而加入锁，日誌的写入速度会明显下降，特别是当执行绪数量增加时，这种情况更加明显。

问题

无锁的架构

• 是否可以引入一个无锁的架构来提高效能？比如：
  • 每个执行绪写入到自己的暂存档案中，然后由单独的执行绪进行合併。
  • 使用内存伫列（例如 queue.Queue），将日誌先写入伫列，再统一写入档案。

无锁日誌系统的可能性

如果要避免使用锁，是否可以通过内存伫列缓存日誌内容，让一个专门的写入执行绪负责定期将伫列内容写入档案？但这样的设计会引入新的挑战：

• 如何控制伫列的大小，避免内存溢出？
• 如果系统崩溃，是否会导致伫列中的日誌丢失？

日誌分片与合併

是否应该考虑让每个执行绪将日誌写入不同的档案，然后在后处理阶段进行合併？但这会带来额外的合併开销，并且如何高效合併成为新的问题。

第三方工具的选择

有没有现成的工具或设计模式可以帮助实现这种高效的日誌系统？例如使用 logging 模组的多处理程序功能是否可以解决这些问题？

目前研究

目前我们尝试了一些方案，但都面临挑战：

• 引入锁来解决竞态条件：测试后发现性能下降明显，尤其是执行绪数量增多时。

import threading
import time

# Shared lock for file writing
lock = threading.Lock()

def log_to_file_with_lock(filename, thread_id):
for i in range(5):
with lock: # Ensure exclusive access to the file
with open(filename, "a") as file:
file.write(f"Thread {thread_id} - Log entry {i}\\n")
time.sleep(0.1) # Simulate processing delay

threads = []
filename = "log_with_lock.txt"

# Start multiple threads
for i in range(10): # Increased number of threads to demonstrate scalability issues
t = threading.Thread(target=log_to_file_with_lock, args=(filename, i))
threads.append(t)
t.start()

for t in threads:
t.join()

print("日誌记录完成 (使用锁)。请检查档案内容。")

• 使用内存伫列进行缓冲：性能有一定提升，但需要额外处理伫列溢出和资料丢失的问题。

import queue
import threading
import time

log_queue = queue.Queue(maxsize=50) # Bounded queue to prevent memory overflow

def producer_log_entries(thread_id):
for i in range(5):
try:
log_queue.put_nowait(f"Thread {thread_id} - Log entry {i}\\n")
except queue.Full:
print(f"Thread {thread_id}: Queue is full, dropping log entry.")
time.sleep(0.1)

def consumer_write_logs(filename):
while True:
try:
log_entry = log_queue.get(timeout=1)
with open(filename, "a") as file:
file.write(log_entry)
log_queue.task_done()
except queue.Empty:
break # Exit when no more logs to process

threads = []
filename = "log_with_queue.txt"

# Start the producer threads
for i in range(10): # 10 producer threads
t = threading.Thread(target=producer_log_entries, args=(i,))
threads.append(t)
t.start()

# Start the consumer thread
consumer_thread = threading.Thread(target=consumer_write_logs, args=(filename,))
consumer_thread.start()

# Wait for all producer threads to finish
for t in threads:
t.join()

# Wait for the consumer thread to finish
log_queue.join() # Ensure all items in the queue are processed
consumer_thread.join()

print("日誌记录完成 (使用内存伫列)。请检查档案内容。")

• 日誌分片策略：测试过让每个执行绪写入不同档案，但合併过程中容易出现顺序错乱。

期待大家的回覆与讨论！🙏

3 个回答

• 旧至新
• 新至旧
• 最高Like数

3

I code so I am

iT邦高手 1 级 ‧ 2024-12-26 08:57:19

1. 普通的File IO不支援多执行绪，可使用Python内建模组logging。
2. logging 提供5个level的讯息等级，可在正常运行时过滤某些等级的讯息，只记录重要讯息，反之，在除错时可记录所有讯息。

• 
  2

paulyang0125

iT邦新手 5 级 ‧
2024-12-28 15:55:26

感谢，logging 的确是 Python 中处理日誌的基本解法，讯息等级的过滤功能也很方便。不过在高并发的情境下，logging 虽然是 thread-safe，但效能上可能会因锁的影响出现瓶颈。不知道有没有试过用 QueueHandler 或其他方法来解决这类问题呢？对于顺序和效能的优化有什么建议吗？

感谢，logging 的确是 Python 中处理日誌的基本解法，讯息等级的过滤功能也很方便。不过在高并发的情境下，logging 虽然是 thread-safe，但效能上可能会因锁的影响出现瓶颈。不知道有没有试过用 QueueHandler 或其他方法来解决这类问题呢？对于顺序和效能的优化有什么建议吗？

修改

I code so I am

iT邦高手 1 级 ‧
2024-12-31 08:44:46

logging 支援 SocketHandler，可以实现分散式系统Logging的需求，我初步测试还蛮好的，可参阅：
https://ithelp.ithome.com.tw/articles/10356041

更複杂的解决方案，可考虑Message Queue框架，如RabbitMQ 或 Redis，我曾经使用Redis，效果非常好。

logging 支援 SocketHandler，可以实现分散式系统Logging的需求，我初步测试还蛮好的，可参阅：<br /> https://ithelp.ithome.com.tw/articles/10356041</p> <p>更複杂的解决方案，可考虑Message Queue框架，如RabbitMQ 或 Redis，我曾经使用Redis，效果非常好。<br />

修改

1

kwkevinchan

iT邦新手 5 级 ‧ 2024-12-26 20:09:33

因为 Log 本来就是无序的东西, 尤其是在分散式系统中更是如此
不然你分散在不同 Container 的同一个 app 怎么互相感知并决定谁先谁后写 Log?

一般作法是如果有要将同一 process 产生的 log 串在一起
可以在一开始就产出一个 trace id
并在 log 系统中透过 fliter 扫出来解读

• 
  1

paulyang0125

iT邦新手 5 级 ‧
2024-12-28 15:56:13

kwkevin 的 trace ID 概念很棒！分散式系统中这确实是常见的解决方案。不晓得在 Python 中，有没有哪种日誌框架可以轻鬆整合这样的设计？或是你会建议手动扩展来支援 trace ID？

kwkevin 的 trace ID 概念很棒！分散式系统中这确实是常见的解决方案。不晓得在 Python 中，有没有哪种日誌框架可以轻鬆整合这样的设计？或是你会建议手动扩展来支援 trace ID？

修改

1

麻糬Mouchi

iT邦新手 4 级 ‧ 2024-12-27 00:25:33

我个人会更倾向，把log先快取在记忆体(包含产生的时间戳记)，然后把可能有需要的资讯统一传送独立的纪录服务。但详细的实作过程我也不太确定该怎么弄比较好XD

• 
  1

paulyang0125

iT邦新手 5 级 ‧
2024-12-28 15:57:46

麻糬的想法很实用！快取在记忆体再集中写入确实能解决性能瓶颈。如果加上批次写入和时间戳记，应该能避免queue溢出的问题。不过想问问看，对于独立纪录服务，你觉得会使用哪种框架或架构来实现呢？

麻糬的想法很实用！快取在记忆体再集中写入确实能解决性能瓶颈。如果加上批次写入和时间戳记，应该能避免queue溢出的问题。不过想问问看，对于独立纪录服务，你觉得会使用哪种框架或架构来实现呢？

修改