Get system block size in Java

Question

I'm trying to write the fastest, most optimal file saving method possible. Is there any way to get the system block size in java? Something like System.getProperty("block.size") or something.

Answer 1

I don't think there is a java function to do that. However there is a system dependent way to retrieve that information. Have a look at this answer. You'll need to use Runtime.exec() and parse the data.

Answer 2

The 'fastest most optimal way possible' is surely to write using the biggest buffer you can afford; to make sure its size is a power of two (a megabyte comes to mind); and to make sure that the writes themselves are buffer-aligned:

new BufferedOutputStream(new FileOutputStream(file), 1024*1024);

As long as you are over the system block size, which you will be at this size, and remain aligned with it, which is guaranteed by the BufferedOutputStream, this is about as optimal as it gets.

You should also look into FileChannel.transferTo(), noting that you must call it in a loop, and that the actual implementations so far don't appear to use any low-level operating system primitives (contrary to the advertising), just the same kind of loop you could write yourself.

Answer 3

As of Java 9, you can use the FileSystem and FileStore class to get the system disk block size based on the file system implemented by your native OS. The code is as follows:

    FileSystem fs = FileSystems.getDefault();
    Iterable<Path> roots = fs.getRootDirectories();
    for (FileStore store: fs.getFileStores()) {
        Iterator<Path> i = roots.iterator();
        while(i.hasNext()) {
            if(store.name().startsWith(i.next().toString())) {
                System.out.println("Name: " + store.name() + ", Read only: " + store.isReadOnly() + ", Type: " + store.type() + ", Block: " + store.getBlockSize() + " Bytes");
            }
        }
    }

Answer 4

There's no System property but you can use whatever Java uses for its own needs and rest assured that that's the best for your OS/Java-version combo.

This solution exploits the fact the buf used in Java's BufferedXXXStream classes to hold the data is a protected variable and not a private one:

class IdealBlockSize {
    // You could alternatively use BufferedInputStream and System.in .
    private static class MyBufferedOS extends BufferedOutputStream {
        public MyBufferedOS() { super(System.out); }
        public MyBufferedOS(OutputStream out) { super(out); }
        public int bufferSize() { return buf.length; }
    }

    public static int VALUE = new IdealBlockSize.MyBufferedOS().bufferSize();
}

Then, you can invoke them in your application startup code, like so:

System.out.printf("Ideal block size: %d\n", IdealBlockSize.VALUE);

// Output
// Ideal block size: 8192

This solution allows you to have buffers that are just big enough to be optimal.