C++11原子操作

1.什么是原子操作

2.为什么需要原子操作？

3.C++中的原子操作

4.原子操作使用及注意

5.应用场景

6.使用原子操作的最佳实践

7.原子操作与锁机制的比较

8.总结

1.什么是原子操作

原子操作是一种不可分割的操作，即在多线程环境中，这些操作要么全部执行完成，要么根本没有执行，中间不会被其他线程打断。这种特性使得原子操作在保证数据一致性和线程安全方面具有显著优势。

原子操作是在多线程程序中“最小的且不可并行化的”操作，意味着多个线程访问同一个资源时，有且仅有一个线程能对资源进行操作。通常情况下原子操作可以通过互斥的访问方式来保证，如 Linux下的互斥锁（mutex）和 Windows 下的临界区（Critical Section）等。

说白了原子操作就是不可中断的操作，要么被执行要不不被执行。

2.为什么需要原子操作？

多线程编程的一个核心问题是如何在多个线程间安全地共享数据。传统的解决方案是使用锁（Lock）机制，例如互斥锁（Mutex）和读写锁（Read-Write Lock），但锁机制存在以下缺点：

性能开销大：锁机制会引入额外的上下文切换和系统调用，导致性能下降。

死锁风险：不当的锁管理可能导致死锁，进而影响程序的稳定性。

复杂性高：在复杂的多线程环境中，正确管理锁非常困难，容易出错。

原子操作通过硬件支持，提供了一种轻量级的同步机制，有效避免了上述问题。通过原子操作，我们可以确保在并发环境中对共享数据的访问是安全的，从而避免数据竞争和其他并发问题。

3.C++中的原子操作

C++11引入了标准库头文件，其中包含了原子操作相关的类和函数。最常用的原子操作类是通过模板std::atomic<T>来定义，它封装了基本的原子操作，并提供了一组易于使用的接口。比如atomic_int64_t是通过typedef atomic<int64_t> atomic_int64_t实现的，使用时需包含头文件<atomic>。除了提供atomic_int64_t，还提供了其它的原子类型。常见的原子类型有：

原子类型名称	对应内置类型
atomic_bool	bool
atomic_char	char
atomic_uchar	unsigned char
atomic_short	short
atomic_ushort	unsigned short
atomic_int	int
atomic_uint	unsigned int
atomic_long	long
atomic_ulong	unsigned long
atomic_llong	long long
atomic_ullong	unsigned long long
atomic_char16_t	chat16_t
atomic_char32_t	chat32_t
atomic_wchar_t	wchar_t

原子操作是平台相关的，原子类型能够实现原子操作是因为 C++11 对原子类型的操作进行了抽象，定义了统一的接口，并要求编译器产生平台相关的原子操作的具体实现。C++11 标准将原子操作定义为 atomic 模板类的成员函数，包括读（load）、写（store）、交换（exchange）等。对于内置类型而言，主要是通过重载一些全局操作符来完成的。比如对上文total+=i的原子加操作，是通过对operator+=重载来实现的。使用g++ 编译的话，在 x86_64 的机器上，operator+=() 函数会产生一条特殊的以 lock 为前缀的 x86_64 指令，用于控制总线及实现 x86_64平台上的原子性加法。下面我们通过几个示例代码来了解std::atomic的基本用法：

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>// 原子整数
std::atomic<int> atomicInt(0);void incrementAtomic() {for (int i = 0; i < 1000; ++i) {++atomicInt; // 原子加法}
}int main() {std::vector<std::thread> threads;for (int i = 0; i < 10; ++i) {threads.push_back(std::thread(incrementAtomic));}for (auto& t : threads) {t.join();}std::cout << "Final value: " << atomicInt << std::endl; // 期望输出10000return 0;
}

在上述示例中，我们使用std::atomic定义了一个原子整数atomicInt，并在多个线程中对其进行原子加法操作。由于原子操作的特性，无论有多少个线程同时执行，最终的结果都是正确的（10000），而不会出现数据竞争问题。

有一个比较特殊的原子类型是 atomic_flag，因为 atomic_flag 与其他原子类型不同，它是无锁（lock_free）的，即线程对其访问不需要加锁，而其他的原子类型不一定是无锁的。因为atomic<T>并不能保证类型T是无锁的，另外不同平台的处理器处理方式不同，也不能保证必定无锁，所以其他的类型都会有 is_lock_free() 成员函数来判断是否是无锁的。atomic_flag 只支持 test_and_set() 以及 clear() 两个成员函数，test_and_set()函数检查 std::atomic_flag 标志，如果 std::atomic_flag 之前没有被设置过，则设置 std::atomic_flag 的标志；如果之前 std::atomic_flag 已被设置，则返回 true，否则返回 false。clear()函数清除 std::atomic_flag 标志使得下一次调用 std::atomic_flag::test_and_set()返回 false。可以用 atomic_flag 的成员函数test_and_set() 和 clear() 来实现一个自旋锁（spin lock）：

#include <unistd.h>
#include <atomic>
#include <thread>
#include <iostream>std::atomic_flag lock = ATOMIC_FLAG_INIT;void func1() {while (lock.test_and_set(std::memory_order_acquire))    // 在主线程中设置为true，需要等待t2线程clear{std::cout << "func1 wait" << std::endl;}std::cout << "func1 do something" << std::endl;
}void func2() {std::cout << "func2 start" << std::endl;lock.clear();
}int main() {lock.test_and_set();             // 设置状态std::thread t1(func1);usleep(1);					 	//睡眠1usstd::thread t2(func2);t1.join();t2.join();return 0;
}

以上代码中，定义了一个 atomic_flag 对象 lock，使用初始值 ATOMIC_FLAG_INIT 进行初始化，即处于 false 的状态。线程 t1 调用 test_and_set() 一直返回 true（因为在主线程中被设置过），所以一直在等待，而等待一段时间后当线程 t2 运行并调用了 clear()，test_and_set() 返回了 false 退出循环等待并进行相应操作。这样一来，就实现了一个线程等待另一个线程的效果。当然，可以封装成锁操作的方式，比如：

void Lock(atomic_flag& lock){ while ( lock.test_and_set()); }
void UnLock(atomic_flag& lock){ lock.clear(); }

这样一来，就可以通过Lock()和UnLock()的方式来互斥地访问临界区。

自旋锁使用的时候虽然占用CPU资源（线程在获取锁时会一直循环检查锁是否可用，这会导致线程不断占用CPU时间），但是也有一定的优点：适用于锁被占用时间非常短暂的情况，因为在这种情况下，线程不需要长时间等待锁的释放，使用自旋锁可以避免线程切换带来的开销，提高性能。

4.原子操作使用及注意

原子操作不能拷贝：只要是原子操作，都不能进行赋值和拷贝（因为调用了两个对象，破坏了原子性--拷贝构造和拷贝赋值都会将第一个对象的值进行读取，然后再写入另外一个。对于两个独立的对象，这里就有两个独立的操作了，合并这两个操作必定是不原子的。因此，操作就不被允许。如：

#include <iostream>
#include <atomic>int main() {std::atomic<int> atomicValue(10);// 不能进行赋值操作std::atomic<int> anotherAtomicValue = atomicValue; // 编译错误// 不能进行拷贝操作// std::atomic<int> copiedAtomicValue(atomicValue); // 编译错误return 0;
}