Java多线程竞态条件：原理与实践

什么是竞态条件？

在多线程编程中，当多个线程尝试同时访问和修改同一个共享资源时，如果对资源的访问顺序不确定，并且这种不确定性会导致程序行为的错误或不可预测的结果，就称之为竞态条件（race condition）。竞态条件是并发编程中最常见且难以调试的问题之一，它通常会导致数据不一致、程序崩溃或产生错误输出。

在原始问题中，用户尝试使用多线程计算一个数组的和，但并未遇到竞态条件。这是因为每个线程负责计算数组的一个独立分段，并将结果存储在其自身的局部变量 sum 中。最终的总和是通过将这些独立的局部和累加起来获得的。在这种设计下，线程之间并没有共享可变的资源，因此不会发生竞态条件。要真正演示竞态条件，我们需要一个所有线程都共同读写的数据。

演示竞态条件：共享计数器示例

为了清晰地演示竞态条件，我们将创建一个简单的场景：多个线程并发地对一个共享的整数计数器进行递增和递减操作。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class RaceConditionDemo implements Runnable {
    private int counter = 0; // 共享资源

    /**
     * 递增计数器。为了增加竞态条件发生的概率，引入短暂的睡眠。
     */
    public void increment() {
        try {
            // 模拟复杂操作或上下文切换，增加竞态条件发生的可能性
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新设置中断状态
            e.printStackTrace();
        }
        counter++; // 非原子操作：读取-修改-写入
    }

    /**
     * 递减计数器。
     */
    public void decrement() {
        counter--; // 非原子操作：读取-修改-写入
    }

    /**
     * 获取当前计数器的值。
     */
    public int getValue() {
        return counter;
    }

    @Override
    public void run() {
        this.increment();
        System.out.println("线程 " + Thread.currentThread().getName() + " 递增后值: " + this.getValue());

        this.decrement();
        System.out.println("线程 " + Thread.currentThread().getName() + " 递减后值: " + this.getValue());
    }

    public static void main(String args[]) {
        RaceConditionDemo sharedCounter = new RaceConditionDemo(); // 共享的计数器实例

        // 创建并启动多个线程，它们都操作同一个 sharedCounter 实例
        Thread t1 = new Thread(sharedCounter, "Thread-1");
        Thread t2 = new Thread(sharedCounter, "Thread-2");
        Thread t3 = new Thread(sharedCounter, "Thread-3");
        Thread t4 = new Thread(sharedCounter, "Thread-4");
        Thread t5 = new Thread(sharedCounter, "Thread-5");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

代码分析与竞态条件原因

在这个 RaceConditionDemo 示例中：

1. 共享资源：private int counter = 0; 是一个所有线程共享的实例变量。
2. 非原子操作：counter++ 和 counter-- 看起来是单个操作，但实际上它们包含三个步骤：
   • 读取 counter 的当前值。
   • 对读取到的值进行递增/递减。
   • 将新值写回 counter。 这些步骤在多线程环境下不是原子性的，意味着在一个线程完成这三个步骤之前，CPU可能会切换到另一个线程执行。
3. Thread.sleep(10) 的作用：在 increment() 方法中引入短暂的 Thread.sleep(10)，旨在增加线程上下文切换的概率。当一个线程在执行 counter++ 的读取阶段后、写入阶段前暂停，其他线程就有机会读取到一个“过期”的值，从而导致最终结果错误。

运行结果分析

运行上述 RaceConditionDemo 类，你可能会观察到类似以下的不稳定输出（具体输出会因运行环境和时机而异）：

立即学习“Java免费学习笔记（深入）”；

线程 Thread-3 递增后值: 5
线程 Thread-5 递增后值: 5
线程 Thread-1 递增后值: 5
线程 Thread-2 递增后值: 5
线程 Thread-2 递减后值: 1
线程 Thread-4 递增后值: 5
线程 Thread-1 递减后值: 2
线程 Thread-5 递减后值: 3
线程 Thread-3 递减后值: 4
线程 Thread-4 递减后值: 0

分析要点：

喵记多

喵记多 - 自带助理的 AI 笔记

27

查看详情

• 预期行为：如果所有操作都是顺序执行的，每个线程先递增再递减，那么理论上 counter 变量在每个线程完成其所有操作后，其值应该最终回到 0。每个线程在递增后打印的值应该是 1，递减后打印的值应该是 0。
• 实际观察：
  • 你会看到多个线程在打印其“递增后值”时，counter 的值可能是 5。这表明在多个线程调用 increment() 方法时，它们都读取了 counter 的某个旧值（例如 0），然后各自递增，并将 5 写回。
  • 接着，在某些线程完成递增操作后，其他线程可能还在执行递增，或者已经开始执行递减。
  • 最终，当所有线程都执行完递增和递减操作后，counter 的最终值可能不是 0，而是 0、1、2 等不可预测的值（在上述示例输出中，最终打印的是 0，但这只是其中一次运行的结果，多次运行可能得到不同结果）。
• 竞态条件体现：例如，Thread-3、Thread-5、Thread-1、Thread-2 和 Thread-4 都可能在 counter 的值为 0 或 1 时读取它，然后各自执行递增操作。由于 Thread.sleep(10) 的存在，它们可能在将递增后的值写回之前被调度器暂停。当它们恢复执行并写入时，可能覆盖了其他线程已经写入的值，导致某些递增操作“丢失”。同样，递减操作也可能出现类似问题。

这种不可预测性正是竞态条件的典型特征。

总结与预防

竞态条件是多线程编程中必须认真对待的问题。理解其发生机制是编写正确并发程序的关键。

预防竞态条件的主要策略包括：

1. 同步机制：使用 synchronized 关键字、java.util.concurrent.locks.Lock 接口（如 ReentrantLock）来确保同一时间只有一个线程可以访问共享资源的关键代码段。
2. 原子操作类：对于简单的计数器操作，可以使用 java.util.concurrent.atomic 包下的原子类，如 AtomicInteger、AtomicLong。这些类提供了原子性的递增、递减等操作，无需显式锁定。
3. 线程安全的数据结构：使用 java.util.concurrent 包中提供的线程安全集合，如 ConcurrentHashMap、CopyOnWriteArrayList 等。
4. 不可变对象：如果共享对象是不可变的，那么多个线程可以安全地读取它，因为它们无法修改其状态，自然也就不会有竞态条件。
5. 线程局部存储（ThreadLocal）：如果每个线程都需要一份独立的资源副本，可以使用 ThreadLocal 来避免共享。

通过正确应用这些并发控制技术，我们可以有效地管理共享资源，避免竞态条件，从而构建出稳定、高效的多线程应用程序。

以上就是Java多线程竞态条件：原理与实践的详细内容，更多请关注php中文网其它相关文章！