Java：如何处理尝试修改同一文件的两个进程

Question

可能的重复：
如何使用 java 锁定文件（如果可能）

我有两个进程调用两个修改同一文本文件的Java 程序。我注意到文本文件的内容缺少数据。我怀疑当一个java程序获取文本文件的写入流时，我认为它会阻止另一个java程序修改它（就像当你打开一个文件时，你无法删除该文件）。除了数据库之外还有其他方法可以解决这个问题吗？ （并不是说数据库解决方案不干净或不优雅，只是我们在操作这个文本文件时编写了很多代码）

编辑

事实证明，我针对这个问题犯了一个错误。我的文本文件中的数据丢失的原因是，

ProcessA: 不断向文本文件中添加数据行

ProcessB: 在开始时，加载所有行将文本字段放入 List 中。然后操作该列表的包含内容。最后，ProcessB 将列表写回，替换文本文件的内容。

这在顺序过程中效果很好。但是当一起运行时，如果ProcessA向文件添加数据，在ProcessB操作List期间，那么当ProcessB code> 将 List 写回，无论刚刚添加的 ProcessA 都将被覆盖。所以我最初的想法是在 ProcessB 写回 List 之前，同步文本文件和 List 之间的数据。因此，当我写回 List 时，它将包含所有内容。所以这是我的努力

public void synchronizeFile(){
    try {
        File file = new File("path/to/file/that/both/A/and/B/write/to");
        FileChannel channel = new RandomAccessFile(file, "rw").getChannel();
        FileLock lock = channel.lock(); //Lock the file. Block until release the lock
        List<PackageLog> tempList = readAllLogs(file);
        if(tempList.size() > logList.size()){
            //data are in corrupted state. Synchronized them.
            for(PackageLog pl : tempList){
                if(!pl.equals(lookUp(pl.getPackageLabel().getPackageId(), pl.getPackageLabel().getTransactionId()))){
                    logList.add(pl);
                }
            }
        }
        lock.release(); //Release the file
        channel.close();
    } catch (IOException e) {
        logger.error("IOException: ", e); 
    }
}

所以 logList 是 ProcessB 想要写出的当前列表。因此，在写出之前，我读取文件并将数据存储到 tempList 中，如果 tempList 和 logList 不同，则同步它们。问题是，此时 ProcessA 和 ProcessB 当前都访问该文件，因此当我尝试锁定该文件并从中读取时 List; tempList = readAllLogs(file);，我要么得到 OverlappingFileLockException，要么得到 java.io.IOException：进程无法访问文件，因为另一个进程已锁定文件的一部分。请帮我解决这个问题:(

EDIT2：我对锁定的理解

public static void main(String[] args){
    File file = new File("C:\\dev\\harry\\data.txt");

    FileReader fileReader = null;
    BufferedReader bufferedReader = null;
    FileChannel channel = null;
    FileLock lock = null;
    try{
        channel  = new RandomAccessFile(file, "rw").getChannel();
        lock = channel.lock();
        fileReader = new FileReader(file);
        bufferedReader = new BufferedReader(fileReader);
        String data;
        while((data = bufferedReader.readLine()) != null){
            System.out.println(data);
        }
    }catch(IOException e){
        e.printStackTrace();
    }finally{
        try {
            lock.release();
            channel.close();
            if(bufferedReader != null) bufferedReader.close();
            if(fileReader != null) fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

，我得到了这个错误IOException：该进程无法访问该文件，因为另一个进程已锁定该文件的一部分

Answer 1

因此，您可以使用 Vineet Reynolds 在他的评论中建议的方法。

如果这两个进程实际上只是同一应用程序中的单独线程，那么您可以在某处设置一个标志来指示文件已打开。

如果它是两个独立的应用程序/进程，则底层文件系统应该锁定文件。当您从输出流中收到 I/O 错误时，您应该能够在该错误周围包装一个 try/catch 块，然后将您的应用程序设置为稍后重试，或者设置您的特定应用程序所需的任何行为。

文件并不是真正设计为由多个应用程序同时写入的。如果您可以描述为什么要从多个进程同时写入文件，则可能会建议其他解决方案。

---

最近编辑后的更新：
好的，所以您至少需要 3 个文件才能完成您所说的操作。您绝对不能尝试同时读取/写入数据到单个文件。您的三个文件是：

1. ProcessA 将新/传入数据转储到
2. ProcessB 当前正在处理的文件
3. 的文件保存 ProcessB 输出的最终“输出”文件。

ProcessB 的循环：

• 获取 file#2 中的任何数据，处理它，并将输出写入 file#3
• 删除 file#2
• 重复

ProcessA 的循环：

• 将所有新的传入数据写入 file#1
• 定期检查 file#2 是否存在
• 何时file#2 被 ProcessB 删除，那么 ProcessA 应该停止写入 file#1，将 file#1 重命名为 file#2
• 开始一个新的 file#1
• 重复

Answer 2

如果这是两个单独的应用程序尝试访问该文件。这个人会通过 IOException 因为他无法访问它。如果发生这种情况，请在 catch(IOException err){} 中添加代码以将当前线程暂停几毫秒，然后递归地尝试再次写入 - 直到它获得访问权限。

public boolean writeFile()
{
    try
    {
       //write to file here
        return true;
    }
    catch (IOException err) // Can't access
    {
        try
        {
            Thread.sleep(200); // Sleep a bit
            return writeFile(); // Try again
        }
        catch (InterruptedException err2)
        {
           return writeFile(); // Could not sleep, try again anyway
        }
    }
}

这将继续尝试，直到您收到 StackOverflow 异常，这意味着它陷入得太深；但在这种情况下发生这种情况的可能性很小 - 只有当文件被其他应用程序保持打开很长时间时才会发生。

希望这有帮助！

Answer 3

更新后的问题中的代码很可能是进程 B 的代码，而不是进程 A 的代码。我假设情况就是如此。

考虑到抛出了 OverlappingFileLockException 异常的实例，看来同一进程中的另一个线程正在尝试锁定同一文件。这不是 A 和 B 之间的冲突，而是 B 内部的冲突，如果查看有关 lock() 方法的 API 文档以及抛出 OverlappingFileLockException 的条件：

如果锁与请求的锁重叠
区域已被该 Java 占用
虚拟机，或者如果另一个线程
已在此方法中被阻止并且
正在尝试锁定重叠的
同一文件的区域

唯一解决方案是阻止 B 中的任何其他线程获取同一文件或文件中同一重叠区域的锁。

抛出的 IOException 有一些更有趣的消息。它可能证实了上述理论，但如果不查看整个源代码，我无法确认任何事情。 lock 方法预计会阻塞，直到获取独占锁。如果获取到了，那么写入文件应该没有问题。除了一个条件。如果文件已由同一 JVM 在不同线程中使用 File 对象（或者换句话说，第二个/不同的文件描述符）打开（并锁定），则对第一个文件描述符的尝试写入将失败，甚至如果获取了锁（毕竟，该锁不会锁定其他线程）。

一种改进的设计是，每个进程中都有一个线程，仅在一定时间内获取文件上的独占锁（当使用单个文件对象或单个文件描述符时），在该文件中执行所需的活动。文件，然后释放锁。

Answer 4

使用 MapReduce 思维来思考这个问题。我们假设每个程序都在写入输出而不读取另一个程序的输出。我会编写两个单独的文件，然后进行“减少”阶段。您的减少可能是一个简单的按时间顺序的合并。

但是，如果您的程序需要彼此的输出。您遇到了一个非常不同的问题，需要重新考虑如何划分工作。

最后，如果两个程序的输出相似但独立，并且您将其写入一个文件以便第三个程序可以读取全部内容，请考虑更改第三个程序以读取这两个文件。