带有守护线程的单例垃圾收集器

Question

我已将记录器实现为单例，其中所有消息都进入队列，守护线程从队列中收集这些消息并打印它们。 我使用守护线程的原因是，一旦我完成它（或应用程序退出），我就不必显式关闭记录器。 我希望在应用程序关闭时（由垃圾收集器）删除记录器，然后 __del__ 方法将运行并在之后进行清理。我很惊讶事实并非如此。

当我将线程更改为非守护程序时，它工作得很好（显然我必须进行一些其他更改才能退出应用程序）。我想知道我做错了什么，或者这只是一个不好的做法。

这里附上代码：（我建议__del__函数之后的所有内容都没有意思）。

import os
import sys
import time
import Queue
import weakref
import datetime
import threading

class Logger(object):
    """
    Logger class implemented with a queue of messages, and supports only a single instace.
    This instance can be acquired by using the "GetLogger" method.
    """

    __instance = None

    @classmethod
    def GetLogger(cls, fpath, source_name=None):

        if cls.__instance is None:

            return Logger(fpath, source_name=source_name)

        else:
          if source_name is None:
              cls.__instance().log('%s@%s: %s\n' % (cls.current_date(), cls.current_time(), "Using existing Logger instance"), "REUSAGE")
          else:
              cls.__instance().log('%s@%s - %-17s: %s\n' % (cls.current_date(), cls.current_time(), source_name, "Using existing Logger instance"), "REUSAGE")

        return cls.__instance()

    def __init__(self, fpath, start_time = time.time(), source_name=None):

        if self.__instance is not None:

            raise ValueError("Singleton object already exists")

        self.__instance = weakref.ref(self)
        self.__start_time = start_time
        self.__queue = Queue.Queue()
        self.__listener = threading.Thread(target=self._listen)
        self.__listener.daemon = True
        self.__listener.start()
        if not os.path.exists(os.path.dirname(fpath)):
            os.makedirs(os.path.dirname(fpath))
        self.__f = open(fpath, 'a')
        if source_name is None:
            self.log('%s@%s: %s\n' % (self.current_date(), self.current_time(), "Created a new Logger instance"), "CREATION")
        else:
            self.log('%s@%s - %-17s: %s\n' % (self.current_date(), self.current_time(), source_name, "Created a new Logger instance"), "CREATION")

    @staticmethod
    def current_date():
        return str(datetime.datetime.now().date().isoformat())

    @staticmethod
    def current_time():
        return str(datetime.datetime.now().time().isoformat())

    def _listen(self):

        while True:

            msg = self.__queue.get()
            if msg is None:
                break

            self.__print_message(msg)

    def __print_message(self, msg_tup): # msg_tup = (message, level, stdout)
        msg_time = time.time()
        if msg_tup[2]:
            try:
                print(("|%013.6f|%-8s>>>%s" % (msg_time - self.__start_time, msg_tup[1], msg_tup[0]))),
                sys.stdout.flush()
            except:
                pass
        try:
            self.__f.write("|%013.6f|%-8s>>>%s" % (msg_time - self.__start_time, msg_tup[1], msg_tup[0]))
            self.__f.flush()
        except:
            pass

    def log(self, msg, level, to_stdout=True):
        self.__queue.put((msg, level, to_stdout))

    def close(self):
        self.__queue.put(None)
        self.__instance = None

    def __del__(self):

        while not self.__queue.empty():
            msg = self.__queue.get()
            if msg is not None:
                self.__print_message(msg)
        print("Dead...")
        self.__f.close()
        self.close()

    def info(self, msg, source_name=None, to_stdout=True):
        if source_name is None:
            self.log('%s@%s: %s\n' % (self.current_date(), self.current_time(), msg), "INFO", to_stdout=to_stdout)
        else:
            self.log('%s@%s - %-17s: %s\n' % (self.current_date(), self.current_time(), source_name, msg), "INFO", to_stdout=to_stdout)

    def debug(self, msg, source_name=None, to_stdout=True):
        if source_name is None:
            self.log('%s@%s: %s\n' %
                               (self.current_date(), self.current_time(), msg), "DEBUG", to_stdout=to_stdout)
        else:
            self.log('%s@%s - %-17s: %s\n' % (self.current_date(), self.current_time(), source_name, msg), "DEBUG", to_stdout=to_stdout)

    def trace(self, msg, sdource_name=None, to_stdout=True):
        if source_name is None:
            self.log('%s@%s: %s\n' %
                               (self.current_date(), self.current_time(), msg), "TRACE", to_stdout=to_stdout)
        else:
            self.log('%s@%s - %-17s: %s\n' % (self.current_date(), self.current_time(), source_name, msg), "TRACE", to_stdout=to_stdout)

    def warn(self, msg, source_name=None, to_stdout=True):
        if source_name is None:
            self.log('%s@%s: %s\n' %
                               (self.current_date(), self.current_time(), msg), "WARN", to_stdout=to_stdout)
        else:
            self.log('%s@%s - %-17s: %s\n' % (self.current_date(), self.current_time(), source_name, msg), "WARN", to_stdout=to_stdout)

    def error(self, msg, source_name=None, to_stdout=True):
        if source_name is None:
            self.log('%s@%s: %s\n' %
                               (self.current_date(), self.current_time(), msg), "ERROR", to_stdout=to_stdout)
        else:
            self.log('%s@%s - %-17s: %s\n' % (self.current_date(), self.current_time(), source_name, msg), "ERROR", to_stdout=to_stdout)

    def critical(self, msg, source_name=None, to_stdout=True):
        if source_name is None:
            self.log('%s@%s: %s\n' %
                               (self.current_date(), self.current_time(), msg), "CRITICAL", to_stdout=to_stdout)
        else:
            self.log('%s@%s - %-17s: %s\n' % (self.current_date(), self.current_time(), source_name, msg), "CRITICAL", to_stdout=to_stdout)

Answer 1

只要程序中的任何“活动”变量仍然包含对它的引用，GC 就永远不会回收您的 Logger 实例。 listen(self):... 方法的 self 参数就是这样一个变量，它是运行守护线程的顶级方法。

def _listen(self):
    while True:
        msg = self.__queue.get()
        if msg is None:
            break
        self.__print_message(msg)

在守护线程从_listen() 返回之前，GC 无法回收Logger 实例。只有一种方法可以做到这一点：

def close(self):
    self.__queue.put(None)

如果您“关闭”您的记录器，那么守护线程最终将从队列中获取None，它将从_listen() 调用返回，并且守护线程将结束。但是，你说

我使用守护线程的原因是我不必显式关闭记录器。

如果你不关闭记录器，那么守护线程永远不会结束，_listen(self) 中的 self arg 永远不会超出范围，Logger 实例永远不会被回收。