16

我们是否需要在使用 Ruby 后关闭 StringIO 对象以释放资源，就像我们对真正的 IO 对象所做的那样？

obj = StringIO.new "some string"
#...
obj.close # <--- Do we need to close it?

细化我的问题

关闭文件对象是必要的，因为它会关闭文件描述符。操作系统中打开文件的数量是有限的，这就是为什么需要关闭 File。但是，如果我理解正确的话，StringIO 是内存中的抽象。我们需要关闭它吗？

4

5 回答 5

22

  • StringIO#close不会释放任何资源或删除其对累积字符串的引用。因此调用它对资源使用没有影响。

  • Only StringIO#finalize，在垃圾回收期间调用，释放对累积字符串的引用，以便可以释放它（前提是调用者不保留自己对它的引用）。

  • StringIO.open，它短暂地创建了一个 StringIO 实例，在它返回后不保留对该实例的引用；因此可以释放 StringIO 对累积字符串的引用（前提是调用者不保留对它的引用）。

  • 实际上，使用 StringIO 时很少需要担心内存泄漏。完成后不要继续对 StringIO 的引用，一切都会好起来的。

潜入源头

StringIO 实例使用的唯一资源是它正在累积的字符串。您可以在 stringio.c (MRI 1.9.3) 中看到这一点；在这里，我们看到了保存 StringIO 状态的结构：

static struct StringIO *struct StringIO {
    VALUE string;
    long pos;
    long lineno;
    int flags;
    int count;
};

当一个 StringIO 实例最终确定（即垃圾回收）时，它对字符串的引用将被丢弃，这样如果没有其他对它的引用，该字符串可能会被垃圾回收。这是 finalize 方法，它也被调用StringIO#open(&block)以关闭实例。

static VALUE
strio_finalize(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    ptr->string = Qnil;
    ptr->flags &= ~FMODE_READWRITE;
    return self;
}

仅当对象被垃圾回收时才调用 finalize 方法。StringIO 没有其他方法可以释放字符串引用。

StringIO#close只是设置一个标志。它不会释放对累积字符串的引用或以任何其他方式影响资源使用：

static VALUE
strio_close(VALUE self)
{   
    struct StringIO *ptr = StringIO(self);
    if (CLOSED(ptr)) {
        rb_raise(rb_eIOError, "closed stream");
    }
    ptr->flags &= ~FMODE_READWRITE;
    return Qnil;
}

最后，当您调用 时StringIO#string，您将获得对 StringIO 实例一直在累积的完全相同的字符串的引用：

static VALUE
strio_get_string(VALUE self)
{   
    return StringIO(self)->string;
}

使用StringIO时如何泄漏内存

所有这一切都意味着 StringIO 实例导致资源泄漏的方式只有一种：您不能关闭 StringIO 对象，并且您必须保留它比保留调用时获得的字符串更长的时间StringIO#string。例如，想象一个具有 StringIO 对象作为实例变量的类：

class Leaker

  def initialize
    @sio = StringIO.new
    @sio.puts "Here's a large file:"
    @sio.puts
    @sio.write File.read('/path/to/a/very/big/file')
  end

  def result
    @sio.string
  end

end

想象一下，这个类的用户得到了结果，简单地使用它，然后丢弃它，但仍然保留对 Leaker 实例的引用。您可以看到 Leaker 实例通过未关闭的 StringIO 实例保留了对结果的引用。如果文件非常大，或者有很多现存的 Leaker 实例，这可能是一个问题。这个简单的（并且是故意的病态的）示例可以通过简单地不将 StringIO 保留为实例变量来解决。如果可以（并且几乎总是可以），最好直接扔掉 StringIO 对象，而不是费力地显式关闭它：

class NotALeaker

  attr_reader :result

  def initialize
    sio = StringIO.new
    sio.puts "Here's a large file:"
    sio.puts
    sio.write File.read('/path/to/a/very/big/file')
    @result = sio.string
  end

end

除此之外，这些泄漏仅在字符串很大或 StringIO 实例众多且StringIO 实例长期存在时才有意义，并且您可以看到很少需要显式关闭 StringIO （如果有的话）。

于 2012-04-11T14:14:53.533 回答
3

回应这里的其他答案：调用close 不会帮助您节省内存。

require "stringio"
sio = StringIO.new
sio.print("A really long string")
sio.close
sio.string # => "A really long string"

“一个非常长的字符串”会一直sio存在，close或者不会close。

那么为什么 StringIO 有close方法呢？鸭打字。close如果您尝试从中读取或写入，则提供IOError 并抛出一个 IOError ，以确保它的行为就像一个真实的File对象。如果您在单元测试时将其用作模拟对象，这将非常有用。

于 2012-04-12T09:04:13.403 回答
3

当您关闭 aFile时，这很重要，因为系统的描述符数量有限（假设您在 UNIX 上，我不知道 Windows 做了什么）。有了StringIO，还有另一个资源处于危险之中：内存。如果StringIO对象有很多要存储的东西，就会从堆中占用大量内存。另一方面，垃圾收集器确实总是关闭IO它声称的对象，但这假设您有一种优雅的方式将您的对象置于范围之外。此外，在负载较重的系统上，物理 RAM 比文件描述符更有价值。在我的 Linux 机器上，178203 是最大文件描述符。我怀疑你能做到这一点。

于 2012-04-11T13:56:30.283 回答
0

一般来说，答案是否定的。I/O 流在被垃圾收集器声明时会自动关闭。对文件 I/O 的回答也相同。

于 2012-04-11T13:13:16.537 回答
-2

不，但它有利于内存优化

于 2012-04-11T13:14:26.583 回答