C++ 数据竞争

2025年2月11日 | 阅读 9 分钟

在 C++ 编程中，当多个线程同时访问同一内存位置，并且其中至少一个线程执行写入操作时，就会发生数据竞争。这可能导致程序出现崩溃、数据损坏或其他不良后果。

数据竞争的定义

当满足以下条件时，就会发生数据竞争：

共享内存：多个线程同时访问同一个内存位置，例如变量或对象。
并发访问：两个或多个线程同时访问共享内存位置。
冲突操作：其中一次访问涉及修改（写入操作），而另一次可以是读取或写入。

避免数据竞争的重要性

防止数据竞争对于确保并发程序的正确性、可靠性和可预测性至关重要。数据竞争会引入不确定性行为，使得故障排除和问题复现变得困难。此外，它们还会通过允许访问或更改敏感信息而带来安全风险。

数据竞争问题可能导致的结果包括：

结果：如果发生数据竞争，根据 C++ 标准，程序行为被视为未定义。这意味着程序可能表现出任何行为，包括崩溃、不准确的结果，甚至看似正确的行为，但这种行为可能会随着编译器优化或硬件配置而变化。
并发问题：当程序的最终结果取决于线程操作的计时或交错方式时，就会出现并发问题。这可能导致输出错误、数据损坏或其他意外行为。
处理一致性和可复现性的挑战：当程序面临并发问题时，每次执行的表现可能都不同，这使得复现和排查任何出现的问题变得很棘手。这种复杂性给调试和测试过程带来了障碍。
解决安全隐患：并发问题有可能产生漏洞，可能导致数据被访问或篡改，对处理敏感信息或在不受信任的环境中运行的应用程序构成安全威胁。

为了减轻这些风险，编写确保线程安全的代码至关重要。这可以通过同步技术（如互斥锁、原子操作或 C++ 库提供的其他并发工具）来管理对共享数据的访问来实现。

数据竞争的原因

在 C++ 中，并发问题可能由以下因素引起：

1. 共享可变数据；

当存在可变共享数据时，就会出现并发问题。
当多个线程能够同时访问并可能修改共享变量或内存位置时，就可能导致数据竞争。
共享数据可能包括全局变量、静态变量、堆分配的数据结构或多个线程交互的对象属性。

2. 没有适当同步的并发访问

当多个线程在没有使用同步机制的情况下访问可随时更改的共享数据时，可能会发生数据冲突。
同步工具（如互斥锁、信号量或原子操作）至关重要，以确保在任何给定时刻只有一个线程能够使用和更新共享数据。
如果不同时正确使用或完全跳过同步工具，可能会导致对共享数据的不同步访问，从而导致数据冲突。

3. 缺乏内存屏障/围栏；

内存屏障或围栏是指用于强制执行内存操作排序规则的指令。它们确保其他线程或处理器按正确的顺序看到某些操作。
有时，即使采取了同步措施，如果未正确实现所需的内存屏障或围栏，数据冲突仍可能发生。
编译器和处理器可能会重新排列指令。应用可能破坏内存操作预期顺序的优化，如果不受内存屏障或围栏的控制，可能会导致数据冲突。
对内存排序规则的关注不足或对内存屏障/围栏的误用可能导致共享数据的访问，从而导致冲突。

示例

我们来看一个演示数据竞争的 C++ 程序：

#include <iostream>
#include <thread>
#include <vector>

int shared_counter = 0;

void increment_counter(int num_iterations) {
    for (int i = 0; i < num_iterations; ++i) {
        // Data race occurs here
        ++shared_counter;
    }
}

int main() {
    const int num_threads = 5;
    const int iterations_per_thread = 100000;

    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(increment_counter, iterations_per_thread);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "Expected final counter value: " << num_threads * iterations_per_thread << std::endl;
    std::cout << "Actual final counter value: " << shared_counter << std::endl;

    return 0;
}   

输出

 
Expected final counter value: 500000
Actual final counter value: 378542

说明

在此示例中
1. 我们有一个名为 'shared_counter' 的变量。
2. 多个线程在没有任何同步的情况下同时增加此计数器。
3. '++shared_counter' 操作不是原子的，这会导致数据冲突。
由于数据冲突的性质，计数器的最终值每次运行程序时都可能不同。需要注意的主要几点是：
1. 计数器的实际最终值低于预期值。
2. 多次运行程序时，结果会有所不同。
这种不一致之所以发生，是因为多个线程在没有同步的情况下读取和修改 'shared_counter'。增量操作 ('++shared_counter') 不是原子的。它可以分解为三个步骤：
1. 读取值
2. 增加值
3. 将值写回内存
这些步骤可能在线程之间重叠，导致更新丢失。例如：
- 线程 A 读取计数器（值为 100）
- 线程 B 读取计数器（值为 100）
- 当线程 A 将值增加到 101 并更新它时，线程 B 也使用其数据将其增加到 101 并更新值。在这种情况下，一次增量似乎被忽略了。
意外和不正确的结果突显了多线程程序中数据冲突的危险。要解决此问题，至关重要的是采用同步方法，例如互斥锁或原子操作，如前所述。

数据竞争的影响

数据竞争可能在程序中引起问题。以下是主要后果：

1. 不可预测的行为

不确定的结果：由于线程执行的计时，数据竞争可能导致每次运行相同程序时产生不同的结果。

难以复现错误：由数据竞争引起的错误通常是偶发的，难以复现，这使得它们难以进行故障排除和修复。

2. 应用程序崩溃

内存访问冲突：对内存位置的并发写入可能导致内存访问冲突和应用程序崩溃。

无效内存状态：数据竞争可能导致内存处于一种状态，当应用程序尝试从这些内存位置读取或写入时，可能导致应用程序崩溃。

3. 信息损坏

不一致的数据：同时读写共享数据可能导致数据值发生变化，可能影响程序的某些部分。

更新冲突：当两个线程同时更新共享变量时，一个更新可能会丢失，导致程序状态不正确。

4. 性能问题

响应时间延迟：数据竞争可能导致线程不必要地相互等待，从而导致延迟和效率降低。

资源浪费：处理数据竞争的后果可能需要一些资源，例如重新执行任务或管理损坏的数据。

5. 处理死锁和活锁

死锁：虽然与数据竞争没有直接关系，但用于防止它们的错误同步可能导致死锁，即线程陷入等待状态。

活锁：与死锁类似，当线程不断根据对方的响应改变状态但却没有进展时，就会发生活锁。

预防策略

为避免这些问题，必须使用同步方法，如互斥锁、锁和原子操作。遵循既定的编程指南至关重要。ThreadSanitizer 和静态分析工具等工具在开发过程中识别和解决数据竞争问题方面非常有价值。

C++ 编程中防止数据冲突的方法

在 C++ 中防止数据冲突有几种方法。以下是其中一些：

1. 使用互斥锁

互斥锁也称为排他对象。它们用于保护共享信息免受多个线程的访问。

示例

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

int shared_counter = 0;
std::mutex counter_mutex;

void increment_counter(int num_iterations) {
    for (int i = 0; i < num_iterations; ++i) {
        std::lock_guard<std::mutex> lock(counter_mutex);
        ++shared_counter;
    }
}

int main() {
    const int num_threads = 10;
    const int iterations_per_thread = 100000;

    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(increment_counter, iterations_per_thread);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "Expected final counter value: " << num_threads * iterations_per_thread << std::endl;
    std::cout << "Actual final counter value: " << shared_counter << std::endl;

    return 0;
}   

输出

 
Expected final counter value: 1000000
Actual final counter value: 1000000

2. 原子操作

原子操作提供了一种在不需要显式锁定即可对共享变量执行某些操作的方法。

示例

#include <iostream>
#include <thread>
#include <atomic>
#include <vector>

std::atomic<int> shared_counter(0);

void increment_counter(int num_iterations) {
    for (int i = 0; i < num_iterations; ++i) {
        ++shared_counter;
    }
}

int main() {
    const int num_threads = 10;
    const int iterations_per_thread = 100000;

    std::vector<std::thread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(increment_counter, iterations_per_thread);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "Expected final counter value: " << num_threads * iterations_per_thread << std::endl;
    std::cout << "Actual final counter value: " << shared_counter << std::endl;

    return 0;
}   

输出

 
Expected final counter value: 1000000
Actual final counter value: 1000000

3. 条件变量

条件变量允许线程根据数据值进行同步。它们通常用于生产者-消费者场景。

示例

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

std::queue<int> data_queue;
std::mutex queue_mutex;
std::condition_variable queue_cv;
bool finished = false;

void producer() {
    for (int i = 0; i < 10; ++i) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            data_queue.push(i);
            std::cout << "Produced: " << i << std::endl;
        }
        queue_cv.notify_one();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    
    {
        std::lock_guard<std::mutex> lock(queue_mutex);
        finished = true;
    }
    queue_cv.notify_one();
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(queue_mutex);
        queue_cv.wait(lock, [] { return !data_queue.empty() || finished; });
        
        if (finished && data_queue.empty()) {
            break;
        }
        
        int value = data_queue.front();
        data_queue.pop();
        std::cout << "Consumed: " << value << std::endl;
    }
}

int main() {
    std::thread producer_thread(producer);
    std::thread consumer_thread(consumer);

    producer_thread.join();
    consumer_thread.join();

    return 0;
}   

输出

 
Produced: 0
Consumed: 0
Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3
Produced: 4
Consumed: 4
Produced: 5
Consumed: 5
Produced: 6
Consumed: 6
Produced: 7
Consumed: 7
Produced: 8
Consumed: 8
Produced: 9
Consumed: 9

说明

在最后一个示例中，条件变量确保消费者在队列为空时等待，并在有新数据可用或生产者完成时收到通知。它防止共享队列上的数据竞争，并允许生产者和消费者线程之间的同步通信。

这些方法中的每一种都通过确保在访问共享数据时线程之间进行适当的同步来防止数据竞争。选择哪种方法取决于并发程序的具体需求。

线程安全

线程安全是并发编程中的一个关键概念。它指的是代码在被多个线程同时执行时能够正确运行的能力。

线程安全代码与线程不安全代码

1. 线程安全代码

它可以安全地从多个线程并发调用，而不会导致数据竞争或其他同步问题。
它确保以受控的方式访问共享资源，防止意外行为或数据损坏。
它通常使用同步机制来协调对共享数据的访问。

2. 线程不安全代码

在不冒数据竞争或其他同步风险的情况下，不能安全地从多个线程并发调用。
当多个线程同时访问时，它可能导致未定义行为、数据损坏或不一致的结果。
如果要在多线程环境中使用，则需要外部同步。

编写线程安全代码的指南

最小化共享可变状态
- 减少线程之间共享的数据量。
- 在可能的情况下，对不需要共享的数据使用线程本地存储。
使用同步机制
- 使用互斥锁 (std::mutex) 来保护共享资源。
- 对于具有多个读取者和偶尔写入者的情况，使用读写锁 (std::shared_mutex)。
- 对于简单的共享变量，利用原子操作 (std::atomic)。
应用 RAII（资源获取即初始化）原则
- 使用锁保护 (std::lock_guard, std::unique_lock) 来确保正确的互斥锁锁定和解锁。
避免数据竞争
- 确保所有对共享可变数据的访问都经过适当同步。
- 使用 ThreadSanitizer 等工具来检测潜在的数据竞争。
注意内存模型
- 在处理原子变量时，理解并使用适当的内存排序语义。
- 必要时使用内存屏障或围栏来确保内存操作的正确排序。
为并发设计
- 在可用时使用线程安全的数据结构和算法。
- 对于性能关键部分，考虑无锁和无等待算法。
避免死锁
- 在所有线程中以一致的顺序获取锁。
- 使用 std::lock 或 std::scoped_lock 原子地获取多个锁。
处理异常
- 确保即使抛出异常，锁也会被释放。
- 使用 RAII 包装器来自动管理资源生命周期。
警惕双重检查锁定
- 如果使用双重检查锁定模式，请确保已放置正确的内存屏障。
彻底测试
- 使用压力测试和并发测试工具来验证线程安全性。
- 考虑不同的线程交错和潜在的竞争条件。
记录线程安全性
- 清晰地记录函数和类的线程安全保证。
- 为线程不安全的代码指定任何外部同步要求。
使用更高级别的并发构造
- 考虑使用 std::async、std::future 和 std::promise 进行基于任务的并行处理。
- 利用线程池或任务系统来高效管理多个任务。

遵循这些指南，您可以显著提高代码的线程安全性，并降低出现与并发相关的错误和问题的可能性。

下一话题C/C++ 中关于数据类型和修饰符的有趣事实

C++ 数据竞争

数据竞争的定义

避免数据竞争的重要性

数据竞争的原因

1. 共享可变数据；

2. 没有适当同步的并发访问

3. 缺乏内存屏障/围栏；

示例

说明

数据竞争的影响

1. 不可预测的行为

2. 应用程序崩溃

3. 信息损坏

4. 性能问题

5. 处理死锁和活锁

预防策略

C++ 编程中防止数据冲突的方法

1. 使用互斥锁

2. 原子操作

3. 条件变量

说明

线程安全

1. 线程安全代码

2. 线程不安全代码

编写线程安全代码的指南

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

C++ 数据竞争

数据竞争的定义

避免数据竞争的重要性

数据竞争的原因

1. 共享可变数据；

2. 没有适当同步的并发访问

3. 缺乏内存屏障/围栏；

示例

说明

数据竞争的影响

1. 不可预测的行为

2. 应用程序崩溃

3. 信息损坏

4. 性能问题

5. 处理死锁和活锁

预防策略

C++ 编程中防止数据冲突的方法

1. 使用互斥锁

2. 原子操作

3. 条件变量

说明

线程安全