防止TextIOWrapper以兼容Py2 / Py3的方式关闭GC
我需要实现的是：
给定一个二进制文件，以几种不同的方式对它进行解码，以提供一个TextIOBase API。 理想情况下，这些后续文件可以传递，而不需要明确地追踪它们的寿命。
不幸的是，包装BufferedReader会导致读者在TextIOWrapper超出范围时关闭。
这是一个简单的演示：
In [1]: import io
In [2]: def mangle(x):
...: io.TextIOWrapper(x) # Will get GCed causing __del__ to call close
...:
In [3]: f = io.open('example', mode='rb')
In [4]: f.closed
Out[4]: False
In [5]: mangle(f)
In [6]: f.closed
Out[6]: True
我可以通过重写__del__来解决这个问题（这对我的用例来说是一个合理的解决方案，因为我完全控制了解码过程，我只需要在最后公开一个非常统一的API）：
In [1]: import io
In [2]: class MyTextIOWrapper(io.TextIOWrapper):
...: def __del__(self):
...: print("I've been GC'ed")
...:
In [3]: def mangle2(x):
...: MyTextIOWrapper(x)
...:
In [4]: f2 = io.open('example', mode='rb')
In [5]: f2.closed
Out[5]: False
In [6]: mangle2(f2)
I've been GC'ed
In [7]: f2.closed
Out[7]: False
但是这在Python 2中不起作用：
In [7]: class MyTextIOWrapper(io.TextIOWrapper):
...: def __del__(self):
...: print("I've been GC'ed")
...:
In [8]: def mangle2(x):
...: MyTextIOWrapper(x)
...:
In [9]: f2 = io.open('example', mode='rb')
In [10]: f2.closed
Out[10]: False
In [11]: mangle2(f2)
I've been GC'ed
In [12]: f2.closed
Out[12]: True
我花了一些时间在Python源代码盯着它看起来2.7和3.4之间非常相似，所以我不明白为什么__del__继承自IOBase不是在Python 2重写（甚至在可见的dir ），但似乎仍然被执行。 Python 3完全按照预期工作。
有什么我可以做的吗？
事实证明，在Python 2.7中调用close的解构器基本上没有什么可以做的。 这被硬编码到C代码中。 相反，我们可以通过修改close ，使得它不会关闭时缓冲__del__正在发生的事情（ __del__会前执行_PyIOBase_finalize在C代码给我们一个机会来改变行为close ）。 这可以让GC按照预期close而不让GC关闭缓冲区。
class SaneTextIOWrapper(io.TextIOWrapper):
def __init__(self, *args, **kwargs):
self._should_close_buffer = True
super(SaneTextIOWrapper, self).__init__(*args, **kwargs)
def __del__(self):
# Accept the inevitability of the buffer being closed by the destructor
# because of this line in Python 2.7:
# https://github.com/python/cpython/blob/2.7/Modules/_io/iobase.c#L221
self._should_close_buffer = False
self.close() # Actually close for Python 3 because it is an override.
# We can't call super because Python 2 doesn't actually
# have a `__del__` method for IOBase (hence this
# workaround). Close is idempotent so it won't matter
# that Python 2 will end up calling this twice
def close(self):
# We can't stop Python 2.7 from calling close in the deconstructor
# so instead we can prevent the buffer from being closed with a flag.
# Based on:
# https://github.com/python/cpython/blob/2.7/Lib/_pyio.py#L1586
# https://github.com/python/cpython/blob/3.4/Lib/_pyio.py#L1615
if self.buffer is not None and not self.closed:
try:
self.flush()
finally:
if self._should_close_buffer:
self.buffer.close()
我以前的解决方案使用_pyio.TextIOWrapper ，它比上面的要慢，因为它是用Python编写的，而不是C.
它涉及到简单的覆盖__del__用一个空操作，这也将在的Py2 / 3工作。
一个简单的解决方案是从函数中返回变量并将其存储在脚本范围中，以便在脚本结束或对其引用发生更改之前不会收集垃圾回收。 但是那里可能有其他优雅的解决方案。
编辑：
我发现了一个更好的解决方案（相对而言），但如果任何人都能从中学习，我会留下这个答案。 （这是炫耀gc.garbage一个非常简单的方法）
请勿实际使用以下内容。
旧：
我发现了一个潜在的解决方案，尽管它很糟糕：
我们可以做的是在析构函数中设置循环引用，这将阻止GC事件。 然后，我们可以查看gc的garbage来查找这些不可引用的对象，打破这个循环，并删除该引用。
In [1]: import io
In [2]: class MyTextIOWrapper(io.TextIOWrapper):
...: def __del__(self):
...: if not hasattr(self, '_cycle'):
...: print "holding off GC"
...: self._cycle = self
...: else:
...: print "getting GCed!"
...:
In [3]: def mangle(x):
...: MyTextIOWrapper(x)
...:
In [4]: f = io.open('example', mode='rb')
In [5]: mangle(f)
holding off GC
In [6]: f.closed
Out[6]: False
In [7]: import gc
In [8]: gc.garbage
Out[8]: []
In [9]: gc.collect()
Out[9]: 34
In [10]: gc.garbage
Out[10]: [<_io.TextIOWrapper name='example' encoding='UTF-8'>]
In [11]: gc.garbage[0]._cycle=False
In [12]: del gc.garbage[0]
getting GCed!
In [13]: f.closed
Out[13]: True
实际上，这是一个非常可怕的解决方法，但它对我所提供的API可能是透明的。 尽管如此，我宁愿一个方法来覆盖__del__的IOBase 。
上一篇: Prevent TextIOWrapper from closing on GC in a Py2/Py3 compatible way