InputStream in = ...
synchronized (closeLater(in)) {
  // reading
}

static InputStream closeLater(final InputStream in) {
  new Thread(new Runnable() {
    public void run() {
      try {
        synchronized (in) {
          in.wait(1000);
          in.close();
        }
      } catch (Exception e) { }
    }
  }).start();
  return in;
}

class InputStreamProcessor
{
  private final InputStream stream;
 
  public InputStreamProcessor(InputStream stream)
  {
    this.stream = stream;
  }
 
  void process(StreamReceiver receiver) throws IOException
  {
    byte[] buffer = new byte[1024];
 
    try {
      do {
        int read = stream.read(buffer);
 
        if (!receiver(buffer, read) return;
      } while (read >= 0);
    } finally {
      stream.close();
    }
  }
 
  public interface Receiver
  {
    boolean process(byte[], int len);
  }
}

synchronized(closeLater(in)) {
  ..
}

try {
  ..
} finally {
  try {
    in.close();
  } catch (IOException e) {
    // ignore
  }
}

int[] out = {0};

> InputStream in = ...
> synchronized (closeLater(in)) {
>   // reading
> }

static void closeLater(final InputStream in, final Object sync) {
    if (!Thread.holdsLock(sync)) {
        throw new IllegalStateException("must first synchronize on " + sync);
    }
    Thread t = new Thread(new Runnable() {
        public void run() {
            try { synchronized (sync) { in.close(); } } catch (Exception e) { }
        }
    });
    t.start();
    while (t.getState() != State.BLOCKED) Thread.yield();
}

synchronized void test() throws Exception {
    InputStream in = new ByteArrayInputStream(new byte[0]);
    closeLater(in, this);
    // read...
}

CloseableStack.Mark mark = CloseableStack.mark()
try {
  InputStream in = CloseableStack.open(new FileInputStream(...));
  // ... read, possibly open more streams
} finally {
   mark.close();
}