Alternative to File.deleteOnExit() in Java NIO?

Java IO has File.deleteOnExit(), which is a method that deletes the file it is called on during normal termination of the JVM. I've found this to be very useful for cleaning up temporary files, especially during unit tests.

However, I don't see a method by the same name in Java NIO's Files class. I am aware that I can do path.toFile().deleteOnExit(), but I'd like to know if there is an alternative using NIO.

Is there an alternative? If not, why is there not one?

Short Answer

You can't delete arbitrary files in Java NIO, but you can use the StandardOpenOption.DELETE_ON_CLOSE when opening a new stream, which will delete the file as soon as the stream closes, either by calling .close() (including from a try-with-resources statement) or the JVM terminating. For instance:

Files.newOutputStream(Paths.get("Foo.tmp"), StandardOpenOption.DELETE_ON_CLOSE);

Long Answer

After a great deal of digging around, I found that Java NIO does have a way to delete on exit, but it approaches it in a different way that Java I/O.

First off, the Javadoc for Files.createTempFile() describes three ways to delete files:

> Where used as a work files [sic], the resulting file may be opened > using the DELETE_ON_CLOSE option so that the file is deleted when the > appropriate close method is invoked. Alternatively, a shutdown-hook, > or the File.deleteOnExit() mechanism may be used to delete the file > automatically.

The last choice, File.deleteOnExit() is of course a Java I/O method, which we are trying to avoid. A shutdown-hook is what is happening behind the scenes when you call the aforementioned method. But the DELETE_ON_CLOSE option is pure Java NIO.

Rather than deleting arbitrary files, Java NIO assumes that you are only interested in deleting files that you are actually opening. Therefore, methods that create a new stream such as Files.newOutputStream() can optionally take several OpenOptions, where you can input StandardOpenOption.DELETE_ON_CLOSE. What that does is delete the file as soon as the stream is closed (either by a call to .close() or the JVM exiting).

For instance:

Files.newOutputStream(Paths.get("Foo.tmp"), StandardOpenOption.DELETE_ON_CLOSE);

...will delete the file associated with the stream when the stream is closed, either from an explicit call to .close(), the stream being closed as part of a try-with-resources statement, or the JVM terminating.

Update: On some operating systems such as Linux, StandardOpenOption.DELETE_ON_CLOSE deletes as soon as the OutputStream is created. If all you need is one OutputStream, that may still be okay. See https://stackoverflow.com/q/18146637/531762 for more info.

So Java NIO adds new functionality over Java I/O in that you can delete a file when closing a stream. If that's a good enough alternative to deleting during JVM exit, you can do it in pure Java NIO. If not, you'll have to rely on Java I/O's File.deleteOnExit() or a shutdown-hook to delete the file.

Behind the scenes, File.deleteOnExit() will just create a shutdown hook via Runtime.addShutdownHook().

Then, you can do the same thing with NIO:

Runtime.getRuntime().addShutdownHook(new Thread() {
  public void run() {
    Path path = ...;

    Files.delete(path);
  }
});

I would not suggest shoe-horning StandardOpenOption.DELETE_ON_CLOSE into a replacement for File.deleteOnExit(). As the documentation mentions it's neither intended to be general-purpose, nor is it likely to work correctly outside of trivial cases.

DELETE_ON_CLOSE, as the name implies, is designed to be used to remove a file once it's closed to immediately clean up a no-longer-needed resource. The documentation for Files.createTempFile() is similarly clear on this point, DELETE_ON_CLOSE can be used for "work files" only needed while the file is open.

The Files.createTempFile() docs suggest directly either writing your own shutdown hook or simply continuing to use File.deleteOnExit(). Despite your desire to use NIO there's nothing inherently wrong with using File.deleteOnExit() if you're only working with the local filesystem. If you aren't using (or aren't certain you're using) the local filesystem and therefore can't use File.deleteOnExit() it's straightforward enough to write your own shutdown hook just like what File does:

public final class DeletePathsAtShutdown {
  private static LinkedHashSet<Path> files = new LinkedHashSet<>();

  static {
    Runtime.getRuntime().addShutdownHook(
        new Thread(DeletePathsAtShutdown::shutdownHook));
  }

  private static void shutdownHook() {
    LinkedHashSet<Path> local;
    synchronized {
      local = paths;
      paths = null;
    }

    ArrayList<Path> toBeDeleted = new ArrayList<>(theFiles);
    Collections.reverse(toBeDeleted);
    for (Path p : toBeDeleted) {
      try {
        Files.delete(p);
      } catch (IOException | RuntimeException e) {
        // do nothing - best-effort
      }
    }
  }

  public static synchronized void register(Path p) {
    if (paths == null) {
      throw new IllegalStateException("ShutdownHook already in progress.");
    }
    paths.add(p);
  }
}

Sure, it might be nice if NIO included a similar shutdown hook out of the box, but its absence is no reason to use the wrong tool for the job. You can also add more functionality to DeletePathsAtShutdown, such as a remove() function, or support for deleting directories.