现在我在框架中有一个中心模块，它使用Python 2.6 multiprocessing模块生成多个进程。因为它使用多处理，所以有一个模块级的多处理感知日志，log = multiprocessing.get_logger()。根据文档，这个日志记录器(EDIT)没有进程共享锁，所以你不会在sys. exe中弄乱东西。Stderr(或任何文件句柄)，让多个进程同时写入它。
我现在遇到的问题是框架中的其他模块不支持多处理。在我看来，我需要让这个中心模块上的所有依赖都使用多处理感知日志。这在框架内很烦人，更不用说对框架的所有客户端了。还有我想不到的选择吗?
当前回答
下面是一个可以在Windows环境下使用的类，需要ActivePython。 您还可以继承其他日志处理程序(StreamHandler等)。
class SyncronizedFileHandler(logging.FileHandler):
MUTEX_NAME = 'logging_mutex'
def __init__(self , *args , **kwargs):
self.mutex = win32event.CreateMutex(None , False , self.MUTEX_NAME)
return super(SyncronizedFileHandler , self ).__init__(*args , **kwargs)
def emit(self, *args , **kwargs):
try:
win32event.WaitForSingleObject(self.mutex , win32event.INFINITE)
ret = super(SyncronizedFileHandler , self ).emit(*args , **kwargs)
finally:
win32event.ReleaseMutex(self.mutex)
return ret
下面是一个演示用法的例子:
import logging
import random , time , os , sys , datetime
from string import letters
import win32api , win32event
from multiprocessing import Pool
def f(i):
time.sleep(random.randint(0,10) * 0.1)
ch = random.choice(letters)
logging.info( ch * 30)
def init_logging():
'''
initilize the loggers
'''
formatter = logging.Formatter("%(levelname)s - %(process)d - %(asctime)s - %(filename)s - %(lineno)d - %(message)s")
logger = logging.getLogger()
logger.setLevel(logging.INFO)
file_handler = SyncronizedFileHandler(sys.argv[1])
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
#must be called in the parent and in every worker process
init_logging()
if __name__ == '__main__':
#multiprocessing stuff
pool = Pool(processes=10)
imap_result = pool.imap(f , range(30))
for i , _ in enumerate(imap_result):
pass
其他回答
我喜欢zzzeek的回答。我只会用管道代替队列，因为如果多个线程/进程使用相同的管道端来生成日志消息，它们将被混淆。
然而，另一种选择可能是日志包中各种非基于文件的日志处理程序:
套接字处理程序 数据报处理程序 系统日志处理程序
(和其他人)
通过这种方式，您可以轻松地在某个地方创建一个日志守护进程，以便安全地对其进行写入并正确地处理结果。(例如，一个简单的套接字服务器，它只是解pickle消息并将其发送到自己的旋转文件处理程序。)
SyslogHandler也会为您处理这个问题。当然，您可以使用自己的syslog实例，而不是系统实例。
有一个很棒的套餐
包: https://pypi.python.org/pypi/multiprocessing-logging/
代码: https://github.com/jruere/multiprocessing-logging
安装:
pip install multiprocessing-logging
然后添加:
import multiprocessing_logging
# This enables logs inside process
multiprocessing_logging.install_mp_handler()
其中一个替代方案是将多处理日志写入一个已知文件，并注册一个atexit处理程序来加入这些进程，并在stderr上读取它;但是，您无法通过这种方式获得stderr上输出消息的实时流。
下面是另一个简单的解决方案，适用于从谷歌到这里的其他人(比如我)。日志记录应该很简单!仅适用于3.2或更高版本。
import multiprocessing
import logging
from logging.handlers import QueueHandler, QueueListener
import time
import random
def f(i):
time.sleep(random.uniform(.01, .05))
logging.info('function called with {} in worker thread.'.format(i))
time.sleep(random.uniform(.01, .05))
return i
def worker_init(q):
# all records from worker processes go to qh and then into q
qh = QueueHandler(q)
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.addHandler(qh)
def logger_init():
q = multiprocessing.Queue()
# this is the handler for all log records
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter("%(levelname)s: %(asctime)s - %(process)s - %(message)s"))
# ql gets records from the queue and sends them to the handler
ql = QueueListener(q, handler)
ql.start()
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
# add the handler to the logger so records from this process are handled
logger.addHandler(handler)
return ql, q
def main():
q_listener, q = logger_init()
logging.info('hello from main thread')
pool = multiprocessing.Pool(4, worker_init, [q])
for result in pool.map(f, range(10)):
pass
pool.close()
pool.join()
q_listener.stop()
if __name__ == '__main__':
main()
