我是否需要关闭 java.io package 的 Reader 装饰器？

Question

I need to parse an object and I need to wrap the Reader I receive into a PushbackReader. Do I need to close the PushbackReader in any case or is it safe enough to leave it open since it's the underlying reader (that I didn't open) that

With

public static MyObject parse(Reader reader) throws IOException, ParseException {
  PushbackReader pReader = new PushbackReader(reader, PUSHBACK_SIZE);
  try {
    return parseMyObject(pReader);
  } finally {
    pReader.close();
  }
}

Or is it safe enough to write only the following:

public static MyObject parse(Reader reader) throws IOException, ParseException {
  return parseMyObject(new PushbackReader(reader, PUSHBACK_SIZE));
}

---

For info, here's how I call my parser:

BufferedReader reader = new BufferedReader(...);
try {
  while (...) {
    list.add(MyObjectParser.parse(reader));
  }
} catch (IOException e) {
  throw new RuntimeException("Could not read the stream", e);
} catch (ParseException e) {
  throw new ParseRuntimeException("Could not parse the stream", e);
} finally {
  // No need for null check.
  reader.close();
}

Answer 1

You don't need to call close() on the PushbackReader if the callee will be closing the underlying Reader . The PushbaseReader is just a wrapper with a buffer that'll be garbage collected when you're done with it. Calling close() on it will close the underlying Reader , which you'll want to keep if you expect the method to be closing it.

Update : Based on your code it looks like you can't call close() on the PushbackReader because it'll also close your underlying Reader . The next iteration should fail with an exception about the stream being closed if you do that, from what I can see. Eg this example fails:

BufferedReader reader = new BufferedReader(new StringReader("foo"));
new PushbackReader(reader).close();
reader.read(); // IOException: Stream closed

Answer 2

It's not too complicated if you remember a few key points:

• It's okay to close a stream/Reader/Writer more than once. A second (or subsequent) close has no effect.
• Stream wrappers ( PushBackReader , BufferedReader etc.) do close the underlying stream when the wrapper is closed.
• The garbage collector does not in general automatically close a stream unless the stream owns on OS resource (file descriptor, socket etc.)
• Typically the creator of a stream will (using a try - finally block) close the stream when finished with it, eg

Reader reader = new FileReader(file);
try {
    parse(reader);
} finally {
    reader.close();
}

So as a general rule parse() should not close the reader unless it has a good reason to do so (eg an IOException has left the stream in an indeterminate state) in case the caller wishes to use the stream for something else.

It's probably not the end of the world if parse closes the stream when it has finished with it, but if it does then you should definitely document the fact.

Answer 3

It is best practice that you always close your readers - if they happen to be wrappers to other readers then they should cascade the close operation to them.

In your code snippet, it is just a matter of deciding where the responsibility resides. Someone should close the reader, either the parse method or the parseMyObject method. I prefer the parse method because then the code is more readable - the same method that created/opened the reader is the one closing it.
(otherwise you get into strange situations - someone else can use the parseMyObject and then suddenly be surprised that it closed the reader argument)

UPDATE:

Now that I see the update to your question, this boils down to accepting a reader parameter in a loop, and then wrapping it multiple times. I suggest that you refactor your code so you wrap it with the PushbackReader only once. Or move the initialization code of the reader into the inner method.