C++ 互斥锁、自旋锁和原子操作

Qfuuu

于 2024-10-02 16:08:15 发布

阅读量654

点赞数 41

文章标签： c++

本文链接：https://blog.csdn.net/qq_50373827/article/details/142682177

版权

C++ 互斥锁、自旋锁和原子操作对比表

特性	互斥锁 (Mutex)	自旋锁 (Spinlock)	原子操作 (Atomic Operations)
定义	保证同一时间仅有一个线程访问资源	线程忙等待，检查锁的状态	不可分割的操作
使用场景	复杂数据结构或长时间操作	短时间的锁定，避免上下文切换	简单计数器、状态标志
性能	较低（可能阻塞）	较高（无阻塞）	最高（轻量级）
实现方式	`std::mutex`	`std::atomic_flag`	`std::atomic<T>`
线程安全	是	是	是
适用性	一般	特定条件下	简单场景

1. 互斥锁 (Mutex)

背景

互斥锁是一种基本的线程同步机制，用于防止多个线程同时访问共享资源。其产生的原因在于多线程编程中常常会出现数据竞争和不一致性的问题。例如，如果两个线程同时尝试更新一个共享变量，最终的结果可能不符合预期。互斥锁通过确保在任意时刻只能有一个线程访问临界区，来避免这些问题。

原理

锁的状态管理：互斥锁在底层使用操作系统的线程管理功能，具有两种状态：锁定和未锁定。线程在请求锁时：
- 如果锁未被占用，线程可以获取锁并执行临界区代码。
- 如果锁已被占用，线程将被阻塞，直到锁被释放。
死锁：死锁发生在两个或多个线程互相等待对方释放锁。使用 RAII（资源获取即初始化）原则，像 std::lock_guard 这样的工具可以有效防止死锁，因为它确保锁在作用域结束时自动释放。

性能考虑

开销：互斥锁的实现通常涉及系统调用，这可能导致开销和延迟，特别是在高竞争环境中。
上下文切换：当线程在等待锁时，操作系统可能会进行上下文切换，导致性能下降。

示例代码

#include <mutex> // 引入互斥锁头文件
#include <thread> // 引入线程头文件
#include <iostream> // 引入输入输出头文件

std::mutex mtx; // 创建一个互斥锁实例，用于保护共享数据
int shared_data = 0; // 共享数据，所有线程将对其进行访问

// 线程要执行的函数
void increment() {
std::lock_guard<std::mutex> lock(mtx); // 创建 lock_guard 对象，自动上锁
// 通过 lock_guard 保证在此作用域内互斥锁会被解锁
++shared_data; // 修改共享数据
// 输出当前线程的 ID 和更新后的共享数据
std::cout << "Incremented: " << shared_data
<< " by thread: " << std::this_thread::get_id()
<< std::endl; // 使用 this_thread::get_id() 获取当前线程 ID
// 当 lock_guard 对象超出作用域时，互斥锁会自动解锁
}

int main() {
std::thread t1(increment); // 创建线程 t1 执行 increment 函数
std::thread t2(increment); // 创建线程 t2 执行 increment 函数
t1.join(); // 等待线程 t1 完成
t2.join(); // 等待线程 t2 完成
// 输出最终的共享数据
std::cout << "Final shared data: " << shared_data << std::endl; // 最终共享数据
return 0; // 返回 0 表示程序正常结束
}

2. 自旋锁 (Spinlock)

背景

自旋锁是在高性能并发编程中使用的一种轻量级锁。它的设计初衷是减少线程在竞争锁时的上下文切换开销。在某些场景中，例如锁持有时间极短的情况下，自旋锁可以比互斥锁更有效。

原理

忙等待：自旋锁的实现方式是让线程在尝试获取锁时进行忙等待。这意味着线程会在一个循环中反复检查锁的状态，直到成功获取锁。这种方法适合锁持有时间短的场合，因为上下文切换的开销被减少。
原子性：自旋锁通常使用原子变量来表示锁的状态，确保对锁状态的操作是原子性的，从而避免竞态条件。

性能考虑

适用性：自旋锁在锁竞争不严重且临界区执行时间短时，性能表现较好。
CPU 占用：在高竞争情况下，自旋锁会占用 CPU 资源，导致其他线程无法执行，可能降低整体性能。

示例代码

#include <atomic> // 引入原子操作头文件
#include <thread> // 引入线程头文件
#include <iostream> // 引入输入输出头文件

std::atomic_flag spinlock = ATOMIC_FLAG_INIT; // 创建自旋锁并初始化
int shared_data = 0; // 共享数据

// 线程要执行的函数
void increment() {
// 自旋等待获取锁
while (spinlock.test_and_set(std::memory_order_acquire)); // 自旋等待，获取锁
// 进入临界区，安全地修改共享数据
++shared_data;
// 输出当前线程的 ID 和更新后的共享数据
std::cout << "Incremented: " << shared_data
<< " by thread: " << std::this_thread::get_id()
<< std::endl; // 使用 this_thread::get_id() 获取当前线程 ID
spinlock.clear(std::memory_order_release); // 解锁
}

3. 原子操作 (Atomic Operations)

背景

原子操作是现代多线程编程中重要的基础，能够保证在并发环境下对数据的安全访问。它的主要目的是通过避免复杂的锁机制，实现更高效的线程安全访问。

原理

原子性：原子操作指的是在多线程环境中，不会被其他线程中断的操作。它通常由处理器的原子指令支持，确保执行过程中的数据一致性。
实现：C++ 提供了 std::atomic 模板，封装了对基本数据类型的原子操作。对于支持原子操作的类型，所有读写操作都将是原子的。

性能考虑

高效性：原子操作的开销通常低于互斥锁和自旋锁，尤其在需要频繁更新共享状态的场景中。
限制：不适合复杂数据结构的保护，因为原子操作仅能处理单一数据类型。

示例代码

#include <atomic> // 引入原子操作头文件
#include <thread> // 引入线程头文件
#include <iostream> // 引入输入输出头文件

std::atomic<int> atomic_counter(0); // 创建原子计数器，初始值为 0

// 线程要执行的函数
void increment() {
atomic_counter++; // 原子自增
// 输出当前线程的 ID 和更新后的原子计数器
std::cout << "Incremented: " << atomic_counter.load()
<< " by thread: " << std::this_thread::get_id()
<< std::endl; // 使用 this_thread::get_id() 获取当前线程 ID
}

int main() {
std::thread t1(increment); // 创建线程 t1 执行 increment 函数
std::thread t2(increment); // 创建线程 t2 执行 increment 函数
t1.join(); // 等待线程 t1 完成
t2.join(); // 等待线程 t2 完成
// 输出最终的原子计数器值
std::cout << "Final atomic counter: " << atomic_counter.load() << std::endl; // 最终计数器值
return 0; // 返回 0 表示程序正常结束
}

综合示例：同时使用三种锁

在这个综合示例中，我们将展示如何使用互斥锁、自旋锁和原子操作来保护和操作共享数据。

#include <mutex> // 包含互斥锁相关的头文件
#include <atomic> // 包含原子操作相关的头文件
#include <thread> // 包含线程相关的头文件
#include <iostream> // 包含输入输出流相关的头文件

// 创建互斥锁实例，用于保护复杂数据结构
std::mutex mtx;
// 创建自旋锁并初始化，使用 atomic_flag 来表示锁的状态
std::atomic_flag spinlock = ATOMIC_FLAG_INIT;
// 创建一个原子计数器，初始值为 0
std::atomic<int> atomic_counter(0);
// 共享数据，多个线程将对其进行操作
int shared_data = 0;

// 使用互斥锁的函数
void use_mutex() {
std::lock_guard<std::mutex> lock(mtx); // 创建 lock_guard 对象，自动上锁
++shared_data; // 在临界区中安全地修改共享数据
// 输出当前线程的 ID 和更新后的共享数据
std::cout << "Mutex incremented: " << shared_data
<< " by thread: " << std::this_thread::get_id() << std::endl;
// lock_guard 在作用域结束时自动解锁
}

// 使用自旋锁的函数
void use_spinlock() {
// 自旋等待获取锁
while (spinlock.test_and_set(std::memory_order_acquire)); // 忙等待
++shared_data; // 在临界区中安全地修改共享数据
// 输出当前线程的 ID 和更新后的共享数据
std::cout << "Spinlock incremented: " << shared_data
<< " by thread: " << std::this_thread::get_id() << std::endl;
spinlock.clear(std::memory_order_release); // 解锁
}

// 使用原子操作的函数
void use_atomic() {
atomic_counter++; // 原子自增，保证操作的原子性
// 输出当前线程的 ID 和更新后的原子计数器
std::cout << "Atomic incremented: " << atomic_counter.load()
<< " by thread: " << std::this_thread::get_id() << std::endl;
}

int main() {
// 创建多个线程来演示三种锁的使用
std::thread t1(use_mutex); // 创建线程 t1 执行 use_mutex 函数
std::thread t2(use_spinlock); // 创建线程 t2 执行 use_spinlock 函数
std::thread t3(use_atomic); // 创建线程 t3 执行 use_atomic 函数
std::thread t4(use_mutex); // 创建线程 t4 执行 use_mutex 函数
std::thread t5(use_spinlock); // 创建线程 t5 执行 use_spinlock 函数
std::thread t6(use_atomic); // 创建线程 t6 执行 use_atomic 函数

// 等待所有线程完成
t1.join(); // 等待线程 t1 完成
t2.join(); // 等待线程 t2 完成
t3.join(); // 等待线程 t3 完成
t4.join(); // 等待线程 t4 完成
t5.join(); // 等待线程 t5 完成
t6.join(); // 等待线程 t6 完成

// 输出最终的共享数据和原子计数器的值
std::cout << "Final shared data: " << shared_data << std::endl; // 最终共享数据
std::cout << "Final atomic counter: " << atomic_counter.load() << std::endl; // 最终计数器值
return 0; // 返回 0 表示程序正常结束
}