C++中的atomic:原子
在多线程编程中,原子操作是一种重要的技术,可以确保在并发环境中进行无锁操作。C++11 引入了 std::atomic<>
,提供了一种无锁的机制来操作变量,确保在并发环境中访问和修改变量时没有数据竞争。本文将介绍 std::atomic<>
的基本概念、使用场景以及实现原理,并提供一些示例代码来说明其用法。
什么是原子操作?
原子操作是指在多线程环境下,不可分割的操作,即在进行操作时不会被其他线程打断。原子操作是一种以单个事务来执行的操作,其他线程只能看到操作完成前或者完成后的资源状态,不存在中间状态可视。从底层来看,原子操作是一些硬件指令,其原子性由硬件保证,C++11 对原子操作进行了抽象,提供了统一的接口,避免使用时嵌入平台相关的代码来支持跨平台使用。
为什么需要 std::atomic<>
?
虽然 C++11 提供了其他高并发的 API,例如互斥锁(std::mutex
)和条件变量(std::condition_variable
),但这些 API 在某些情况下并不是最佳选择:
- 性能开销:互斥锁的实现通常依赖于操作系统的系统调用,这可能带来较大的性能开销。相反,
std::atomic<>
的操作通常是无锁的,直接使用底层硬件提供的原子操作,性能更高。 - 避免死锁:使用互斥锁需要小心处理锁的获取和释放,否则容易导致死锁。
std::atomic<>
不需要显式加锁和解锁,减少了编程复杂性。 - 细粒度控制:
std::atomic<>
提供了对单个变量的细粒度控制,使得某些简单的并发场景可以更高效地实现。
使用 std::atomic<>
std::atomic<>
是一个模板类,可以实例化各种类型的原子操作。然而,并不是所有类型都可以实例化 std::atomic<>
模板。按照标准的说法,需要是 Trivially Copyable 的类型,简单来说就是满足以下三个条件:
- 连续的内存;
- 拷贝对象意味着按 bit 拷贝(
memcpy
); - 没有虚函数。
用代码来表达则是自定义结构满足下面五个条件:
std::is_trivially_copyable<T>::value
std::is_copy_constructible<T>::value
std::is_move_constructible<T>::value
std::is_copy_assignable<T>::value
std::is_move_assignable<T>::value
示例代码
下面的代码演示了如何使用 std::atomic<>
进行各种原子操作:
#include <ostream>
#include "XLogger.h"
#include <atomic>
#include <sstream>
#include <type_traits>
class AtomicInfo {};
class q_atomic {
public:
q_atomic() {
std::atomic<int32_t> int32_atomic(100);
int32_atomic++;
int32_atomic--;
++int32_atomic;
std::atomic<bool> bool_atomic(false);
/**
* 读取并修改被封装的值,exchange 会将 val 指定的值替换掉之前该原子对象封装的值,并返回之前该原子对象封装的值,
* 整个过程是原子的(因此exchange 操作也称为 read-modify-write 操作)。
*/
std::atomic<bool> atomicBool2 = bool_atomic.exchange(true, std::memory_order_relaxed);
bool_atomic = true;
std::atomic<AtomicInfo> info_atomic;
// 这个错误信息指出 _Atomic 不能应用于 std::string 类型,因为 std::string 不是可平凡复制(trivially copyable)的类型。
// C++ 中 std::atomic<> 只能用于可平凡复制的类型,例如基本数据类型(如 int、float)和某些自定义类型,但 std::string 不符合这一要求。
// todo 为什么 std::string 不能直接用于 std::atomic<>?
// std::string 是一个复杂的类型,包含动态分配的内存,其复制操作涉及更多的资源管理,不能保证在并发环境下安全地进行无锁操作。
// 使用锁 或 包装string std::atomic<std::shared_ptr<std::string>> atomicString(std::make_shared<std::string>("")); 规避
//std::atomic<std::string> str_atomic;
}
void bring() {
std::atomic<int32_t> atomicInt(100);
/**
* 修改被封装的值
* void store(_Tp __d, memory_order __m = memory_order_seq_cst)
* memory_order __m,指定内存序,操作的类别决定了内存次序所准许的取值。若我们没有把内存次序显式设定成上面的值,
* 则默认采用最严格的内存次序,即std::memory_order_seq_cst
*/
atomicInt.store(100, std::memory_order_seq_cst);
/**
* 读取被封装的值
* _Tp load(memory_order __m = memory_order_seq_cst)
*/
int32_t result = atomicInt.load();
/**
* 检查std::atomic对象是否为无锁实现。
* 返回值:bool,如果当前平台支持无锁实现,返回true,否则返回false。
*
* 判断该 std::atomic 对象是否具备 lock-free 的特性。如果某个对象满足 lock-free 特性,在多个线程访问该对象时不会导致线程阻塞
* 这是一个运行时的判断(C++17提供了编译时判断constexpr is_always_lock_free()),之所以会出现无锁不确定的情况主要是因为对齐alignment。
*/
bool is_lock_free = atomicInt.is_lock_free();
XLOG_INFO("is_lock_free: {0}", is_lock_free);//true
/**
* 设置原子对象的新值,并返回旧值。
* 将 val 指定的值替换掉之前该原子对象封装的值,并返回之前该原子对象封装的值,整个过程是原子的(因此exchange 操作也称为 read-modify-write 操作)。
*/
atomicInt.exchange(12, std::memory_order_seq_cst);
/**
* 原子地比较并交换值。与compare_exchange_weak不同,它在失败时不会进行多次尝试。
* 比较并交换被封装的值与参数 expected 所指定的值是否相等,如果:
* 相等,则用 val 替换原子对象的旧值
* 不相等,则用原子对象的旧值替换 expected ,因此调用该函数之后,如果被该原子对象封装的值与参数 expected 所指定的值不相等,expected 中的内容就是原子对象的旧值。
*
* 如果值被交换,返回true,否则返回false
*
* Tp& __e,预期值的引用
* _Tp __d,要设置的新值。
* memory_order __s, 成功的内存序
* memory_order __f, 失败的内存序
* bool compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f)
*/
int32_t expected = 10;
bool success_ = atomicInt.compare_exchange_strong(expected, 199,std::memory_order_seq_cst, std::memory_order_seq_cst);
XLOG_INFO("compare_exchange_strong: {0}", success_);
/**
* 比较并交换(弱版本,可能会伪失败)。
* 与compare_exchange_strong 不同, weak 版本的 compare-and-exchange 操作允许原子对象所封装的值与参数 expected 的物理内容相同,但却仍然返回 false,
* 不过在某些需要循环操作的算法下这是可以接受的,并且在一些平台下 compare_exchange_weak 的性能更好 。如果 compare_exchange_weak 的判断确实发生了伪失败(spurious failures)——即使原子对象所封装的值与参数 expected 的物理内容相同,
* 但判断操作的结果却为 false,compare_exchange_weak函数返回 false,并且参数 expected 的值不会改变。
*
* 对于某些不需要采用循环操作的算法而言, 通常采用compare_exchange_strong 更好
*
* 如果 atomicInt == expected,则 atomicInt = 20并返回true,否则返回false并将expected设为atomic_int的值
*/
bool exchanged = atomicInt.compare_exchange_weak(expected, 20);
XLOG_INFO("compare_exchange_weak: {0}", exchanged);
/**
* 原子加法,返回旧值。可选的内存顺序,默认为memory_order_seq_cst。
*/
int add_ret = atomicInt.fetch_add(123);
/**
* 原子减法,返回旧值。可选的内存顺序,默认为memory_order_seq_cst。
*/
int sub_ret = atomicInt.fetch_sub(100);
//原子或操作,返回旧值。
atomicInt.fetch_or(1);
//原子与操作,返回旧值。
//old_value = 0b1100, atomic_int = 0b1000
int old_value = atomicInt.fetch_and(0b1010);
//原子异或操作,返回旧值。
atomicInt.fetch_xor(11);
//等待直到atomic_int的值不等于10
atomicInt.wait(10);
atomicInt.notify_one();
atomicInt.notify_all();//通知等待的所有线程。
/**
* 实际调用了 operator T() const, 将foo 强制转换成 int 类型,然后调用 operator=().
* 与 load 功能类似,也是读取被封装的值,operator T() 是类型转换(type-cast)操作,
* 默认的内存序是 std::memory_order_seq_cst,如果需要指定其他的内存序,应该使用 load() 函数。
*/
std::atomic<int32_t> atomicInt2 = static_cast<int>(atomicInt);
}
void task1() {
//编译时常量布尔值,用于检查类型 T 是否是可平凡复制的。一个类型是可平凡复制的,
// 意味着它的复制操作(拷贝构造、拷贝赋值)都可以通过简单的内存复制(如 memcpy)完成,而不需要自定义的拷贝逻辑。
bool copyable = std::is_trivially_copyable<std::string>::value;
XLOG_INFO("std::string-->is_trivially_copyable: {0}", copyable);//false
//编译时常量布尔值,用于检查类型 T 是否是可拷贝构造的。即,类型 T 是否可以通过拷贝构造函数创建新的对象。
//用途: 在模板代码中判断类型是否支持拷贝构造,确保只有支持拷贝构造的类型才能被某些模板实例化。
bool constructible = std::is_copy_constructible<std::string>::value;
XLOG_INFO("std::string-->is_copy_constructible: {0}", constructible);//true
bool is_copy_assignable=std::is_copy_assignable<int32_t>::value;
XLOG_INFO("int32_t-->is_copy_assignable: {0}", is_copy_assignable);//true
//编译时常量布尔值,用于检查类型 T 是否是可移动赋值的。即,类型 T 是否可以通过移动赋值运算符进行赋值操作。
//用途: 在模板代码中判断类型是否支持移动赋值,从而优化代码性能,减少不必要的拷贝操作。
bool move_assignable = std::is_move_assignable<int32_t>::value;
XLOG_INFO("int32_t-->is_move_assignable: {0}", move_assignable);//true
checkTypeTraits<int32_t>();
checkTypeTraits<long>();
checkTypeTraits<std::string>();
}
template <typename T>
void checkTypeTraits() {
std::cout << "Is trivially copyable: " << std::is_trivially_copyable<T>::value << std::endl;
std::cout << "Is copy constructible: " << std::is_copy_constructible<T>::value << std::endl;
std::cout << "Is move constructible: " << std::is_move_constructible<T>::value << std::endl;
std::cout << "Is copy assignable: " << std::is_copy_assignable<T>::value << std::endl;
std::cout << "Is move assignable: " << std::is_move_assignable<T>::value << std::endl;
}
~q_atomic() {}
private:
};
注意事项
std::atomic<>
只能用于可平凡复制的类型,例如基本数据类型(如int
、float
)和某些自定义类型,但std::string
不符合这一要求。std::string
是一个复杂的类型,包含动态分配的内存,其复制操作涉及更多的资源管理,不能保证在并发环境下安全地进行无锁操作。- 可以使用
std::atomic<std::shared_ptr<std::string>>
来处理std::string
,这是一种间接方式,确保线程安全。
总结
std::atomic<>
提供了一种高效、安全的方式来处理多线程环境中的共享数据。通过利用底层硬件的原子操作指令,可以避免使用互斥锁,从而提高性能,并减少死锁的风险。在编写高并发应用程序时,合理使用 std::atomic<>
可以大大简化代码并提高程序的稳定性和性能。
原文地址:https://blog.csdn.net/qq_17338093/article/details/140567507
免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!