使用java.nio.FileChannel从两个不同的JVM同时写入文本文件和从中读取文本文件

Question

I'm trying to write two programs, one that writes to a text file, and the other one that reads from it. I've tried using java.io, but ran into concurrency problems. However, when I switched to java.nio, I ran into even bigger problems, probably not related to concurrency since I lock the file in both programs when trying to read/write, but the actual way of reading from or writing to a file.

Writer program code (the part that is relevant):

Path filePath = Paths.get("map.txt");
FileChannel fileChannel;
ByteBuffer buffer;
StringBuilder existingObjects = new StringBuilder();

while (true) {
    for (FlyingObject fo : airbornUnitsList) {
        existingObjects.append(fo.toString() + System.lineSeparator());
    }
    if(existingObjects.length() > System.lineSeparator().length())
        existingObjects.setLength(existingObjects.length() - System.lineSeparator().length());
    buffer = ByteBuffer.wrap(existingObjects.toString().getBytes());
    fileChannel = FileChannel.open(filePath, StandardOpenOption.READ, StandardOpenOption.WRITE);
    fileChannel.lock();
    fileChannel.write(buffer);
    fileChannel.close();
    existingObjects.delete(0, existingObjects.length());
    sleep(100);
}

FlyingObject is a simple class with some fields and an overridden toString() method and airbornUnitsList is a list of those objects, so I'm basically iterating through the list, appending the FlyingObject objects to StringBuilder object, removing the last "new line" from StringBuilder, putting it into the buffer and writing to the file. As you can see, I have locked the file prior to writing to the file and then unlocked it afterwards.

Reader program code (the part that is relevant):

Path filePath = Paths.get("map.txt");
FileChannel fileChannel;
ByteBuffer buffer;
StringBuilder readObjects = new StringBuilder();

while (true) {
    fileChannel = FileChannel.open(filePath, StandardOpenOption.READ, StandardOpenOption.WRITE);
    fileChannel.lock();
    buffer = ByteBuffer.allocate(100);
    numOfBytesRead = fileChannel.read(buffer);

    while (numOfBytesRead != -1) {
        buffer.flip();
        readObjects.append(new String(buffer.array()));
        buffer.clear();
        numOfBytesRead = fileChannel.read(buffer);
    }
    fileChannel.close();
    System.out.println(readObjects);
}

Even when I manually write a few lines in the file and then run the Reader program, it doesn't read it correctly. What could be the issue here?

EDIT: After playing with buffer size a bit, I realized that the file is read wrongly because the buffer size is smaller than the content in the file. Could this be related to file encoding?

Answer 1

I found out what the problem was.

Firstly, in the writer program, I needed to add the fileChannel.truncate(0); after opening the file channel. That way, I would delete the old content of the file and write it from the beginning. Without that line, I would just overwrite the old content of the file with new content when writing and if the new content is shorter than the old content, the old content would still remain in those positions not covered by new content. Only if I was sure that the new content is at least as big as the old content and would rewrite it completely, I wouldn't need the truncate option, but that wasn't the case for me.

Secondly, regarding the reader, the reason it wasn't reading the whole file is because the while loop would end before the last part of the file content was appended to the StringBuilder . After I modified the code and changed the order of operations a bit, like this:

numOfBytesRead = 0;

    while (numOfBytesRead != -1) {
        numOfBytesRead = fileChannel.read(buffer);
        buffer.flip();
        readObjects.append(new String(buffer.array()));
        buffer.clear();
    }

it worked without problems.