Cannot delete file ...bug?

Question

This appears like a bug to me...see if you agree.
A file opened for read-only access and memory mapped using the map method of FileChannel cannot be deleted even when the channel is closed. An example of this is the simple Grep.java example from NIO modified only to try and delete the file. On Win2K, the delete fails. Once the channel is closed, it should be able to delete the file. Is this a bug?
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.util.regex.*; public class Grep {     // Charset and decoder for ISO-8859-15
private static Charset charset = Charset.forName("ISO-8859-15");
private static CharsetDecoder decoder = charset.newDecoder(); // Pattern used to parse lines
private static Pattern linePattern
= Pattern.compile(".*\r?\n"); // The input pattern that we're looking for
private static Pattern pattern; // Compile the pattern from the command line
private static void compile(String pat) {
try {
pattern = Pattern.compile(pat);
} catch (PatternSyntaxException x) {
System.err.println(x.getMessage());
System.exit(1);
} // Use the linePattern to break the given CharBuffer into lines, applying
// the input pattern to each line to see if we have a match
private static void grep(File f, CharBuffer cb) {
Matcher lm = linePattern.matcher(cb);// Line matcher
Matcher pm = null;// Pattern matcher
int lines = 0;
while (lm.find()) {
lines++;
CharSequence cs = lm.group(); // The current line
if (pm == null)
pm = pattern.matcher(cs);
else
pm.reset(cs);
if (pm.find())
System.out.print(f + ":" + lines + ":" + cs);
if (lm.end() == cb.limit())
break;
} // Search for occurrences of the input pattern in the given file
private static void grep(File f) throws IOException { // Open the file and then get a channel from the stream
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel(); // Get the file's size and then map it into memory
int sz = (int)fc.size();
MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, sz); // Decode the file into a char buffer
CharBuffer cb = decoder.decode(bb); // Perform the search
grep(f, cb); // Close the channel and the stream
fc.close();
// Try deleting the file =================================
boolean deleted = f.delete();
if (!(deleted)) {
System.err.println("Could not delete file " + f.getName());
System.exit(4);
// End try deleting file =================================
} public static void main(String[] args) {
if (args.length < 2) {
System.err.println("Usage: java Grep pattern file...");
return;
compile(args[0]);
for (int i = 1; i < args.length; i++) {
File f = new File(args);
try {
grep(f);
} catch (IOException x) {
System.err.println(f + ": " + x);

Answer 1

Here is the minimal code that demonstrates this. It opens the file specified on the command line, maps it to memory, prints it out, and then tries to delete the file.
There is no question about calling close on a File object. The close method is invoked on a stream or a channel. In the case of a channel, it should automatically close the stream. However, in this code I am closing the stream and the channel.
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
public class testFileDelete {
public static void main(String[] args) {
          FileInputStream fis = null;
          if (args.length < 1) {
               System.err.println("Usage: java testFileDelete <filename>");
               System.exit(1);
          File f = new File(args[0]);
try {
               // Open the file
               fis = new FileInputStream(f);
          } catch (FileNotFoundException ex) {
               System.err.println("Error! " + ex.getMessage());
               System.exit(2);
          try {
               // Get a channel from the stream
               FileChannel fc = fis.getChannel();
               // Map the file into memory
               MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, (int)fc.size());
               // Do something interesting here. For this example, just print the
               // contents of the file.
               // Decode the file into a char buffer, so we can print the contents.
               Charset cs = Charset.forName("8859_1");
               CharsetDecoder cd = cs.newDecoder();
               CharBuffer cb = cd.decode(bb);
               // Now print it out to standard output
          System.out.print(cb);
               // Close the channel and the stream
               fc.close();
               // Close the input stream even though closing the
               // channel should do this
               fis.close();
          } catch (IOException ex) {
               System.err.println("Error! " + ex.getMessage());
               System.exit(3);
          // Done processing file. Now delete it.
          boolean deleted = f.delete();
          if (!(deleted)) {
               System.err.println("Could not delete file " + f.getName());
               System.exit(2);