Detailed explanation of python log printing and writing concurrency implementation code-Python Tutorial-php.cn

Detailed explanation of python log printing and writing concurrency implementation code

高洛峰

Release： 2017-03-21 09:04:37

Original

2342 people have browsed it

Everyone generally uses logging for printing, but logging is thread-safe. There are also many introductions to multi-process. Introducing some file locks and configuring logging can ensure support.

However, through testing, it was found that when there are multiple processes, it is still easy to have the problem of repeatedly writing files or missing files when printing is normal.

My logging requirements are relatively simple, I can distinguish files and write log files correctly.

Introducing file locks; the log writing function is encapsulated into an operation_Logger class; the log name and writing level are encapsulated into a business class Logger.

This example is implemented based on python3. In this example, 20 processes are concurrently writing to 3 files respectively. Each file writes more than 100 lines of data every second. There is no data redundancy or data omission in the log file.

Detailed explanation of python log printing and writing concurrency implementation code

# -*-coding:utf-8-*- 
"""
Author：yinshunyao
Date:2017/3/5 0005下午 10:50
"""
# import logging
import os
import time
# 利用第三方系统锁实现文件锁定和解锁
if os.name == &#39;nt&#39;:
    import win32con, win32file, pywintypes
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
    LOCK_SH = 0  # The default value
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
    __overlapped = pywintypes.OVERLAPPED()


    def lock(file, flags):
        hfile = win32file._get_osfhandle(file.fileno())
        win32file.LockFileEx(hfile, flags, 0, 0xffff0000, __overlapped)

    def unlock(file):
        hfile = win32file._get_osfhandle(file.fileno())
        win32file.UnlockFileEx(hfile, 0, 0xffff0000, __overlapped)

elif os.name == &#39;posix&#39;:
    from fcntl import LOCK_EX


    def lock(file, flags):
        fcntl.flock(file.fileno(), flags)

    def unlock(file):
        fcntl.flock(file.fileno(), fcntl.LOCK_UN)
else:
    raise RuntimeError("File Locker only support NT and Posix platforms!") 



class _Logger:
    file_path = &#39;&#39;    #初始化日志路径

    @staticmethod
    def init():

        if not _Logger.file_path:
            _Logger.file_path = &#39;%s/Log&#39; % os.path.abspath(os.path.dirname(__file__))
        return True

    @staticmethod
    def _write(messge, file_name):
        if not messge:
            return True
        messge = messge.replace(&#39;\t&#39;, &#39;,&#39;)
        file = &#39;{}/{}&#39;.format(_Logger.file_path, file_name)
        while True:
            try:
                f = open(file, &#39;a+&#39;)
                lock(f, LOCK_EX)
                break
            except:
                time.sleep(0.01)
                continue

        # 确保缓冲区内容写入到文件
        while True:
            try:
                f.write(messge + &#39;\n&#39;)
                f.flush()
                break
            except:
                time.sleep(0.01)
                continue

        while True:
            try:
                unlock(f)
                f.close()
                return True
            except:
                time.sleep(0.01)
                continue
        @staticmethod
    def write(message, file_name, only_print=False):
        if not _Logger.init(): return
        print(message)
        if not only_print:
            _Logger._write(message, file_name)


class Logger:
    def __init__(self, logger_name, file_name=&#39;&#39;):
        self.logger_name = logger_name
        self.file_name = file_name    # 根据消息级别，自定义格式，生成消息

    def _build_message(self, message, level):
        try:
            return &#39;[%s]\t[%5s]\t[%8s]\t%s&#39; \
                   % (time.strftime(&#39;%Y-%m-%d %H:%M:%S&#39;), level, self.logger_name, message)
        except Exception as e:
            print(&#39;解析日志消息异常：{}&#39;.format(e))
            return &#39;&#39;

    def warning(self, message):
        _Logger.write(self._build_message(message, &#39;WARN&#39;), self.file_name)

    def warn(self, message):
        _Logger.write(self._build_message(message, &#39;WARN&#39;), self.file_name)

    def error(self, message):
        _Logger.write(self._build_message(message, &#39;ERROR&#39;), self.file_name)

    def info(self, message):
        _Logger.write(self._build_message(message, &#39;INFO&#39;), self.file_name, True)

    def debug(self, message):
        _Logger.write(self._build_message(message, &#39;DEBUG&#39;), self.file_name) 
# 循环打印日志测试函数


def _print_test(count):
    logger = Logger(logger_name=&#39;test{}&#39;.format(count), file_name=&#39;test{}&#39;.format(count % 3))
    key = 0
    while True:
        key += 1
        # print(&#39;{}-{}&#39;.format(logger, key))
        logger.debug(&#39;%d&#39; % key)
        logger.error(&#39;%d&#39; % key)

if __name__ == &#39;__main__&#39;:
    from multiprocessing import Pool, freeze_support
    freeze_support()    # 进程池进行测试
    pool = Pool(processes=20)
    count = 0
    while count < 20:
        count += 1
        pool.apply_async(func=_print_test, args=(count,))
    else:
        pool.close()
        pool.join()

Copy after login

The above is the detailed content of Detailed explanation of python log printing and writing concurrency implementation code. For more information, please follow other related articles on the PHP Chinese website!