JAVA 多线程文件写入错乱？使用 ReentrantLock 确保原子性写入 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JAVA 多线程文件写入错乱：ReentrantLock 的原子性保障

大家好，今天我们来探讨一个在多线程编程中常见的问题：多线程并发写入文件导致数据错乱。以及如何利用 ReentrantLock 来确保文件写入的原子性，从而避免数据损坏。

问题重现：多线程文件写入的并发冲突

在单线程环境下，文件写入操作通常是顺序执行的，数据按照预期的顺序写入文件。然而，在多线程环境下，多个线程可能同时尝试写入同一个文件，如果没有适当的同步机制，就会发生并发冲突，导致写入的数据交错、覆盖，最终造成文件内容错乱。

举个例子，假设我们有两个线程，分别负责写入以下内容到同一个文件：

线程 1: "AAAA"
线程 2: "BBBB"

如果没有同步机制，可能出现以下几种情况：

交错写入: 文件内容变为 "AABBABAA" 这种乱序组合。
数据覆盖: 线程 1 先写入 "AAAA"，然后线程 2 写入 "BBBB"，文件内容变为 "BBBB" (假设线程 2 的写入操作覆盖了线程 1 的写入操作)。
部分覆盖: 文件内容变为 "AAAABBBB" 或者 "BBBAAAAA", 甚至更复杂的组合。

为了更直观地说明这个问题，我们来看一段简单的示例代码：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class ConcurrentFileWrite {

    public static void main(String[] args) {
        String filePath = "output.txt";

        Runnable writer1 = () -> {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) { // append mode
                for (int i = 0; i < 1000; i++) {
                    writer.write("AAAA");
                    writer.newLine();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        };

        Runnable writer2 = () -> {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) { // append mode
                for (int i = 0; i < 1000; i++) {
                    writer.write("BBBB");
                    writer.newLine();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        };

        Thread thread1 = new Thread(writer1);
        Thread thread2 = new Thread(writer2);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("File writing completed.");
    }
}

运行这段代码，你会发现 output.txt 文件的内容是混乱的，"AAAA" 和 "BBBB" 交错出现，而不是预期的 1000 行 "AAAA" 之后紧跟着 1000 行 "BBBB"。

原因分析:

每个线程都独立地打开文件，执行写入操作，然后关闭文件。在没有同步机制的情况下，多个线程可以同时打开文件，并尝试在相同的位置写入数据。由于文件 IO 操作并非原子性的，线程之间的写入操作会相互干扰，导致数据错乱。

解决方案：ReentrantLock 的原子性保障

为了解决多线程文件写入的并发冲突，我们需要一种机制来保证文件写入操作的原子性。 ReentrantLock 是 Java 并发包 java.util.concurrent.locks 中提供的一个可重入的互斥锁，它可以用来控制对共享资源的访问，确保同一时刻只有一个线程可以执行特定的代码块。

ReentrantLock 的工作原理：

加锁 (lock()): 线程尝试获取锁。如果锁当前没有被其他线程持有，则该线程成功获取锁，并可以执行被锁保护的代码块。如果锁已经被其他线程持有，则该线程进入阻塞状态，等待锁被释放。
解锁 (unlock()): 线程释放锁。释放锁后，其他等待该锁的线程会被唤醒，并尝试获取锁。
可重入性: 同一个线程可以多次获取同一个锁，每次获取锁都需要对应地释放锁。

使用 ReentrantLock 解决文件写入并发冲突：

我们修改之前的代码，使用 ReentrantLock 来保护文件写入操作：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.concurrent.locks.ReentrantLock;

public class ConcurrentFileWriteWithLock {

    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        String filePath = "output_locked.txt";

        Runnable writer1 = () -> {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) {
                for (int i = 0; i < 1000; i++) {
                    lock.lock(); // Acquire the lock before writing
                    try {
                        writer.write("AAAA");
                        writer.newLine();
                    } finally {
                        lock.unlock(); // Release the lock after writing
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        };

        Runnable writer2 = () -> {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) {
                for (int i = 0; i < 1000; i++) {
                    lock.lock(); // Acquire the lock before writing
                    try {
                        writer.write("BBBB");
                        writer.newLine();
                    } finally {
                        lock.unlock(); // Release the lock after writing
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        };

        Thread thread1 = new Thread(writer1);
        Thread thread2 = new Thread(writer2);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("File writing completed.");
    }
}

在这个修改后的代码中，我们引入了一个 ReentrantLock 对象 lock。在每个线程的 run() 方法中，我们在写入文件之前调用 lock.lock() 获取锁，确保同一时刻只有一个线程可以执行写入操作。在写入操作完成后，我们在 finally 块中调用 lock.unlock() 释放锁，确保即使在写入过程中发生异常，锁也能被正确释放。

运行这段代码，你会发现 output_locked.txt 文件的内容是正确的，先是 1000 行 "AAAA"，然后是 1000 行 "BBBB"。

代码解释:

private static final ReentrantLock lock = new ReentrantLock();: 创建一个静态的 ReentrantLock 对象。 static 保证所有线程共享同一个锁实例。 final 保证锁对象不会被重新赋值。
lock.lock();: 尝试获取锁。如果锁已经被其他线程持有，当前线程会阻塞，直到锁被释放。
try { ... } finally { lock.unlock(); }: 使用 try-finally 块来确保锁在任何情况下都能被释放，即使在 try 块中发生异常。这是使用锁的最佳实践，可以避免死锁。

ReentrantLock 的高级特性

除了基本的加锁和解锁功能之外，ReentrantLock 还提供了一些高级特性，例如：

公平锁 (Fair Lock): ReentrantLock 可以配置为公平锁，这意味着等待时间最长的线程会优先获得锁。默认情况下，ReentrantLock 是非公平锁，允许线程"插队"获取锁，以提高性能。创建公平锁的方式是 ReentrantLock lock = new ReentrantLock(true); 参数 true 表示创建公平锁。
可中断锁 (Interruptible Lock): 线程在等待锁的过程中可以被中断。可以使用 lock.lockInterruptibly() 方法来获取可中断锁。如果线程在等待锁的过程中被中断，会抛出 InterruptedException 异常。
定时锁 (Timed Lock): 线程可以尝试在指定的时间内获取锁。可以使用 lock.tryLock(long timeout, TimeUnit unit) 方法来获取定时锁。如果线程在指定的时间内没有获取到锁，会返回 false。

公平锁 vs. 非公平锁：

特性	公平锁	非公平锁
锁获取顺序	等待时间最长的线程优先获得锁	允许线程"插队"获取锁，不保证等待时间最长的线程优先
性能	通常性能较低，因为需要维护等待队列	通常性能较高，因为减少了线程上下文切换
适用场景	资源竞争激烈，需要保证所有线程都能公平地访问资源	资源竞争不激烈，对公平性要求不高

可中断锁的应用场景：

当线程需要响应中断请求时，可以使用可中断锁。例如，如果一个线程正在执行一个耗时的任务，并且需要能够响应用户的取消请求，可以使用可中断锁。

定时锁的应用场景：

当线程需要在指定的时间内完成任务时，可以使用定时锁。例如，如果一个线程需要从数据库中读取数据，并且需要在 5 秒内完成，可以使用定时锁。如果 5 秒内没有获取到锁，可以认为数据库连接超时，并执行相应的处理。

使用 ReentrantLock 的注意事项

确保锁的释放: 务必使用 try-finally 块来确保锁在任何情况下都能被释放，避免死锁。
避免过度锁定: 只锁定需要保护的代码块，避免过度锁定导致性能下降。
选择合适的锁类型: 根据实际需求选择合适的锁类型（公平锁、非公平锁、可中断锁、定时锁）。
理解可重入性: 理解 ReentrantLock 的可重入性，避免出现意外的死锁。

其他可选方案

除了 ReentrantLock，还有其他一些方法可以实现多线程文件写入的同步：

synchronized 关键字： Java 内置的同步机制，可以用来保护代码块或方法，确保同一时刻只有一个线程可以执行被 synchronized 保护的代码。
FileChannel 和 FileLock： 使用 java.nio 包中的 FileChannel 和 FileLock 可以实现文件级别的锁定。
使用队列： 将所有要写入的数据放入一个队列中，然后使用一个单独的线程从队列中取出数据并写入文件。这种方式可以避免多线程并发写入文件，但需要额外的队列管理开销。

synchronized 关键字示例：

public class ConcurrentFileWriteSynchronized {

    private static final Object lock = new Object();

    public static void main(String[] args) {
        String filePath = "output_synchronized.txt";

        Runnable writer1 = () -> {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) {
                for (int i = 0; i < 1000; i++) {
                    synchronized (lock) {
                        writer.write("AAAA");
                        writer.newLine();
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        };

        // ... (writer2 类似)
    }
}

FileChannel 和 FileLock 示例：

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;

public class ConcurrentFileWriteFileLock {

    public static void main(String[] args) {
        String filePath = "output_filelock.txt";

        Runnable writer1 = () -> {
            try (RandomAccessFile file = new RandomAccessFile(filePath, "rw");
                 FileChannel channel = file.getChannel()) {
                for (int i = 0; i < 1000; i++) {
                    try (FileLock lock = channel.lock()) { // Exclusive lock
                        file.write(("AAAAn").getBytes());
                    } // Lock is released automatically when the try-with-resources block exits
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        };

        // ... (writer2 类似)
    }
}

各种方案的比较：

方案	优点	缺点	适用场景
`ReentrantLock`	灵活性高，提供了公平锁、可中断锁、定时锁等高级特性，可以更精细地控制锁的行为。	需要手动加锁和解锁，容易忘记解锁导致死锁。	需要更精细的锁控制，例如需要使用公平锁或可中断锁。
`synchronized`	简单易用，Java 内置的同步机制，不需要额外的库依赖。	功能相对简单，只能实现基本的互斥锁，无法实现公平锁、可中断锁等高级特性。	简单的同步需求，例如保护少量的代码块或方法。
`FileChannel` 和 `FileLock`	可以实现文件级别的锁定，避免多个进程或线程同时写入同一个文件。	粒度较大，锁定整个文件可能会影响并发性能。	需要保护整个文件，避免多个进程或线程同时写入同一个文件。
队列	可以避免多线程并发写入文件，简化同步逻辑。	需要额外的队列管理开销，可能会增加程序的复杂性。	对写入顺序有严格要求，或者需要异步写入文件。

选择哪种方案取决于具体的应用场景和需求。

总结：选择合适的同步方案

我们讨论了多线程文件写入错乱的问题，并介绍了如何使用 ReentrantLock 来确保文件写入的原子性。 ReentrantLock 提供了灵活的锁控制机制，可以有效地解决并发冲突，避免数据损坏。此外，我们还介绍了其他一些可选的同步方案，例如 synchronized 关键字、 FileChannel 和 FileLock，以及使用队列的方式。在实际开发中，应该根据具体的应用场景和需求，选择合适的同步方案。

在选择同步方案时，需要权衡各种因素，例如性能、灵活性、复杂性等。没有一种方案是万能的，只有最适合特定场景的方案。理解各种同步方案的优缺点，才能做出明智的选择，编写出高效、可靠的多线程程序。