是否有一种 Java 方法可以预先分配驱动器空间以供应用程序独占使用？
这个空间不需要是一个单独的文件系统或现有文件系统的一部分（因此很容易成为一个数据库），但它应该允许保留指定数量的空间并允许随机读取/写入高足够的吞吐量。
【问题讨论】：
这是我基于 JNA 的 fallocate 解决方案的精简版。主要技巧是获取本机文件描述符。到目前为止，我只在 Linux 上测试过它，但它应该适用于所有现代 POSIX/非 Windows 系统。在 Windows 上没有必要，因为默认情况下 Windows 不会创建稀疏文件（仅使用 StandardOpenOption.SPARSE），因此 RandomAccessFile.setLength(size) 或 FileChannel.write(ByteBuffer.allocate(1), size - 1) 就足够了。
/**
* Provides access to operating system-specific {@code fallocate} and
* {@code posix_fallocate} functions.
*/
public final class Fallocate {
private static final boolean IS_LINUX = Platform.isLinux();
private static final boolean IS_POSIX = !Platform.isWindows();
private static final int FALLOC_FL_KEEP_SIZE = 0x01;
private final int fd;
private int mode;
private long offset;
private final long length;
private Fallocate(int fd, long length) {
if (!isSupported()) {
throwUnsupported("fallocate");
}
this.fd = fd;
this.length = length;
}
public static boolean isSupported() {
return IS_POSIX;
}
public static Fallocate forChannel(FileChannel channel, long length) {
return new Fallocate(getDescriptor(channel), length);
}
public static Fallocate forDescriptor(FileDescriptor descriptor, long length) {
return new Fallocate(getDescriptor(descriptor), length);
}
public Fallocate fromOffset(long offset) {
this.offset = offset;
return this;
}
public Fallocate keepSize() {
requireLinux("fallocate keep size");
mode |= FALLOC_FL_KEEP_SIZE;
return this;
}
private void requireLinux(String feature) {
if (!IS_LINUX) {
throwUnsupported(feature);
}
}
private void throwUnsupported(String feature) {
throw new UnsupportedOperationException(feature +
" is not supported on this operating system");
}
public void execute() throws IOException {
final int errno;
if (IS_LINUX) {
final int result = FallocateHolder.fallocate(fd, mode, offset, length);
errno = result == 0 ? 0 : Native.getLastError();
} else {
errno = PosixFallocateHolder.posix_fallocate(fd, offset, length);
}
if (errno != 0) {
throw new IOException("fallocate returned " + errno);
}
}
private static class FallocateHolder {
static {
Native.register(Platform.C_LIBRARY_NAME);
}
private static native int fallocate(int fd, int mode, long offset, long length);
}
private static class PosixFallocateHolder {
static {
Native.register(Platform.C_LIBRARY_NAME);
}
private static native int posix_fallocate(int fd, long offset, long length);
}
private static int getDescriptor(FileChannel channel) {
try {
// sun.nio.ch.FileChannelImpl declares private final java.io.FileDescriptor fd
final Field field = channel.getClass().getDeclaredField("fd");
field.setAccessible(true);
return getDescriptor((FileDescriptor) field.get(channel));
} catch (final Exception e) {
throw new UnsupportedOperationException("unsupported FileChannel implementation", e);
}
}
private static int getDescriptor(FileDescriptor descriptor) {
try {
// Oracle java.io.FileDescriptor declares private int fd
final Field field = descriptor.getClass().getDeclaredField("fd");
field.setAccessible(true);
return (int) field.get(descriptor);
} catch (final Exception e) {
throw new UnsupportedOperationException("unsupported FileDescriptor implementation", e);
}
}
}
【讨论】：
jdk.internal.access.SharedSecrets.getJavaIOFileDescriptorAccess().get(descriptor);
您可以尝试使用 RandomAccessFile 对象并使用 setLength() 方法。
例子：
File file = ... //Create a temporary file on the filesystem your trying to reserve.
long bytes = ... //number of bytes you want to reserve.
RandomAccessFile rf = null;
try{
rf = new RandomAccessFile(file, "rw"); //rw stands for open in read/write mode.
rf.setLength(bytes); //This will cause java to "reserve" memory for your application by inflating/truncating the file to the specific size.
//Do whatever you want with the space here...
}catch(IOException ex){
//Handle this...
}finally{
if(rf != null){
try{
rf.close(); //Lets be nice and tidy here.
}catch(IOException ioex){
//Handle this if you want...
}
}
}
注意：在创建 RandomAccessFile 对象之前，该文件必须存在。
然后可以使用 RandomAccessFile 对象读取/写入文件。确保目标文件系统有足够的可用空间。该空间可能不是“独占”的，但您始终可以使用文件锁来做到这一点。
P.S：如果您最终意识到硬盘驱动器很慢且无用（或从一开始就打算使用 RAM），您可以使用 java.nio 中的 ByteBuffer 对象。 allocate() 和 allocateDirect() 方法应该绰绰有余。字节缓冲区将被分配到 RAM（和可能的 SwapFile）中，并且是这个 java 程序独有的。可以通过更改缓冲区的位置来完成随机访问。由于这些缓冲区使用有符号整数来引用位置，因此最大大小限制为 2^31 - 1。
详细了解 RandomAccessFile here。
阅读有关 FileLock（java 对象）here 的更多信息。
阅读更多关于 ByteBuffer here.
【讨论】：
setLength 实际上不会在大多数生产文件系统（例如 ext4 和 xfs，它们默认使用稀疏文件）上为文件分配存储空间。 fallocate 答案是最正确的。然而，它的主要优点是持久性（无需同步/刷新块分配元数据）和可靠性（由于磁盘已满，内存映射文件上没有 SIGBUS）；性能实际上可能没有太大差异。
lseek() 管理的，所以您在这方面可能是正确的。虽然使用 fallocate() 如果从 java 中使用，JNI 可能会工作。
setLength 调用ftruncate（通过JVM_SetLength 原语）在POSIX 系统上实际设置长度（lseek 仅用于移动文件指针）。 ftruncate 不预先分配，这就是为什么fallocate 是必要的（但在 JDK 中没有使用）。我将在此处包含基于 JNA 的答案。
length 而不是setLength 的源代码，并确定lseek 是它进行的唯一功能调用。我的观点仍然是标准，因为没有仅限 java 的方法来做到这一点（尽管您基于 JNA 的答案似乎可以工作）。你完成后我很想看看。
在 Linux 系统上，您可以使用 fallocate() 系统调用。它非常快。只需运行 Bash 命令。
UPD：
fallocate -l 10G 10Gigfile
【讨论】：
您可以通过编写一个大文件来预先分配空间，但老实说我不会打扰。性能会非常好/可能比您需要的更好。
如果您真的需要性能，您会编写 C++/C# 并执行 RAW I/O。
但这通常只在编写 RDBMS 引擎、大容量媒体捕获或类似内容时完成。
【讨论】：