原子操作和锁的区别

兴趣使然HX

已于 2025-03-06 16:46:05 修改

阅读量1.2k

点赞数 13

CC 4.0 BY-SA版权

文章标签： c++ 算法开发语言

于 2025-02-26 11:10:13 首次发布

本文链接：https://blog.youkuaiyun.com/XinCurry/article/details/145873103

原子操作 和锁是并发编程中两种常用的同步机制，它们都可以用来解决多线程环境下的数据竞争问题，但它们的实现方式、性能特点和适用场景有很大不同。下面详细分析它们的区别。

1. 定义与实现

原子操作

定义：原子操作是指一个不可分割的操作，要么全部执行成功，要么全部不执行，不会出现中间状态。
实现：原子操作通常由硬件指令（如 CAS，Compare-And-Swap）或编译器提供的原子类型（如 C++ 的 std::atomic）实现。

示例：

#include <atomic>
std::atomic<int> counter(0);

void increment() {
    counter.fetch_add(1, std::memory_order_relaxed); // 原子操作
}

锁

定义：锁是一种同步机制，用于保护临界区，确保同一时间只有一个线程可以访问共享资源。
实现：锁通常基于操作系统提供的同步原语（如互斥锁、读写锁）或用户空间的实现（如自旋锁）。

示例：

#include <mutex>
std::mutex mtx;
int counter = 0;

void increment() {
    mtx.lock();   // 加锁
    ++counter;    // 访问共享资源
    mtx.unlock(); // 解锁
}

2. 性能特点

原子操作

高效：原子操作通常由硬件指令直接支持，性能开销较低。
无阻塞：原子操作不会导致线程阻塞，适合高并发场景。
适用范围有限：原子操作只能用于简单的操作（如加减、比较交换），复杂的操作无法直接实现。

锁

较高开销：锁的实现通常涉及操作系统调用（如 futex），可能导致线程阻塞和上下文切换，性能开销较大。
适用范围广：锁可以保护任意复杂的临界区，适用性更强。
可能阻塞：如果锁被占用，请求锁的线程会被阻塞，直到锁被释放。

3. 适用场景

原子操作

简单操作：适用于对单个变量进行简单的读写、加减、比较交换等操作。
高性能场景：适用于对性能要求较高的场景，如计数器、标志位等。
无阻塞需求：适用于不能接受线程阻塞的场景。

锁

复杂操作：适用于需要保护复杂临界区的场景，如对多个变量的操作、复杂的数据结构等。
通用性：适用于各种同步需求，如生产者-消费者模型、读写锁等。
阻塞可接受：适用于可以接受线程阻塞的场景。

4. 代码示例对比

原子操作示例

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

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

void increment() {
    for (int i = 0; i < 100000; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed); // 原子操作
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Final value of counter: " << counter << std::endl;
    return 0;
}

锁示例

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

std::mutex mtx;
int counter = 0;

void increment() {
    for (int i = 0; i < 100000; ++i) {
        mtx.lock();   // 加锁
        ++counter;    // 访问共享资源
        mtx.unlock(); // 解锁
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Final value of counter: " << counter << std::endl;
    return 0;
}

5. 实现机制对比

原子操作

硬件支持：原子操作通常由 CPU 提供的硬件指令实现，如 CAS（Compare-And-Swap）、LL/SC（Load-Linked/Store-Conditional）等。
无锁编程：原子操作是无锁编程的基础，可以实现无锁数据结构（如无锁队列、无锁栈等）。

锁

操作系统支持：锁的实现通常依赖于操作系统提供的同步原语，如 futex、信号量等。
阻塞机制：锁的实现通常涉及线程的阻塞和唤醒，可能导致上下文切换。

6. 优缺点对比

原子操作

优点：
- 性能高，适合高并发场景。
- 不会导致线程阻塞。
缺点：
- 只能用于简单的操作。
- 实现复杂的数据结构较为困难。

锁

优点：
- 适用性广，可以保护任意复杂的临界区。
- 实现简单，易于理解和使用。
缺点：
- 性能开销较大，可能导致线程阻塞和上下文切换。
- 容易出现死锁、优先级反转等问题。

7. 总结

特性	原子操作	锁
实现方式	硬件指令（如 CAS）或编译器提供的原子类型	操作系统同步原语（如 futex）或用户空间实现
性能	高效，无阻塞	较高开销，可能导致阻塞
适用场景	简单操作（如计数器、标志位）	复杂操作（如保护临界区、复杂数据结构）
优点	高性能，无阻塞	适用性广，易于使用
缺点	只能用于简单操作	性能开销大，可能出现死锁

选择建议

如果需要对单个变量进行简单的操作（如加减、比较交换），并且对性能要求较高，优先选择 原子操作。
如果需要保护复杂的临界区或操作多个共享资源，优先选择锁。

通过理解原子操作和锁的区别，可以更好地选择合适的同步机制来解决并发编程中的问题。

8. 原子操作为什么可以避免两个线程同时读取旧值并写入新值的情况，底层原理是什么

原子操作能够避免两个线程同时读取旧值并写入新值的情况，其底层原理主要依赖于硬件指令和内存屏障。以下是详细的解释：

8.1. 硬件指令的支持

原子操作的实现通常依赖于硬件提供的特殊指令，这些指令能够确保操作的不可分割性。最常见的硬件指令是 CAS（Compare-And-Swap）。

CAS（Compare-And-Swap）

CAS 是原子操作的核心指令，它的作用是比较并交换：

操作过程：
1. 读取内存中的当前值。
2. 比较当前值是否与期望值相等。
3. 如果相等，则将新值写入内存；否则，操作失败。
原子性：CAS 指令是硬件级别的原子操作，不会被其他线程中断。

示例：
假设有两个线程同时对变量 x 进行递增操作：

线程 A 读取 x 的值为 10。
线程 B 也读取 x 的值为 10。
线程 A 使用 CAS 将 x 从 10 更新为 11，成功。
线程 B 尝试使用 CAS 将 x 从 10 更新为 11，但发现 x 的值已经变为 11，操作失败。
线程 B 重新读取 x 的值（11），并尝试将 x 从 11 更新为 12，成功。

通过 CAS 指令，可以确保只有一个线程能够成功更新变量的值，从而避免了数据竞争。

8.2. 内存屏障（Memory Barrier）

内存屏障是一种硬件或软件机制，用于控制内存操作的顺序和可见性。在多线程环境下，内存屏障可以确保：

操作顺序：某些操作在内存屏障之前或之后执行。
内存可见性：一个线程对内存的修改对其他线程立即可见。

内存屏障的作用

防止指令重排序：编译器和 CPU 可能会对指令进行重排序以优化性能，但这在多线程环境下可能导致问题。内存屏障可以防止这种重排序。
确保内存一致性：内存屏障可以确保一个线程对内存的修改对其他线程立即可见。

示例：

std::atomic<int> x(0);
std::atomic<bool> ready(false);

void thread1() {
    x.store(42, std::memory_order_relaxed);  // 宽松内存顺序
    ready.store(true, std::memory_order_release);  // 释放操作，插入内存屏障
}

void thread2() {
    while (!ready.load(std::memory_order_acquire)) {}  // 获取操作，插入内存屏障
    std::cout << x.load(std::memory_order_relaxed) << std::endl;
}

thread1 中的 memory_order_release 确保 x.store 在 ready.store 之前完成。
thread2 中的 memory_order_acquire 确保 x.load 在 ready.load 之后完成。
通过内存屏障，thread2 能够正确读取 x 的值。

8.3. 原子操作的底层实现

原子操作的底层实现通常结合了硬件指令和内存屏障。以下是一个典型的原子操作（如 fetch_add）的实现过程：

读取当前值：从内存中读取变量的当前值。
计算新值：基于当前值计算新值（如加 1）。
CAS 操作：使用 CAS 指令尝试将变量的值从当前值更新为新值。
重试机制：如果 CAS 失败（说明其他线程已经修改了变量的值），则重新读取当前值并重复上述过程。

伪代码：

int fetch_add(std::atomic<int>& x, int value) {
    int old_value = x.load();  // 读取当前值
    while (true) {
        int new_value = old_value + value;  // 计算新值
        if (x.compare_exchange_weak(old_value, new_value)) {  // CAS 操作
            return old_value;  // 返回旧值
        }
        // CAS 失败，重新读取当前值并重试
    }
}