当前位置：首页 > news >正文

C++11中的std::atomic保证的原子性是什么

news 来源：原创 2024/5/9 16:35:48

文章目录

前言
C++中的atomic
一个简单的自增运算
通过加锁把自增变为原子操作
使用atomic来保证自增的原子性
总结

前言

提到atomic这个词，你首先想到的是什么呢？作为一个长时间混迹于编程世界的菜鸟，我首先想到的一个词是“原子性”，接着飞入脑海的是 “ACID” 这个缩写词组，既然提到了 ACID 我们就来简单的复习一下。

ACID 是指事务管理的4个特性，常见于数据库操作管理中，它们分别是：原子性，一致性，隔离性和持久性。

原子性（Atomicity）是指事务是一个不可分割的工作单位，事务中的操作要么都执行，要么都不执行。
一致性（Consistency）是指事务前后数据的完整性必须保持一致，完全符合逻辑原运算。
隔离性（Isolation）是指在多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离，无需感知其他事务的存在。
持久性（Durability）是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对数据造成损坏。

C++中的atomic

原子（atom）是在化学反应中不可分割基本微粒，而编程世界中的原子性也是取自这里的不可分割的含义，不可分割与事务管理中的原子性含义一致，指的是一个操作或者一系列操作只能全都执行或者都不执行，不会只执行其中一部分，那么C++11中引入atomic有什么用？不使用atomic能不能保证原子性呢？

其实C++11中引入atomic主要还是降低了编程的复杂度，如果不使用atomic同样可以使用锁机制来保证原子性，接下来我们来看看为什么需要原子性。

一个简单的自增运算

i++ 是个再简单不过的语句了，我们可以使用它来做一个计数器，每次自增加1，假设我们有一个工程项目有两条商品生产的流水线，每个流水线生产出一件商品则需要计数器加1，这时我们用两个线程来模拟两条流水线，每个线程函数来调用自增的计数器，来看看有什么问题？

#include <iostream>
#include <thread>

int i = 0;

void func(int n)
{
    for (int k = 0; k < n; k++) i++;
}

int main(int argc, char* argv[])
{
    int n = argc > 1 ? atoi(argv[1]) : 100;
    
    std::thread t1(func, n);
    std::thread t2(func, n);
    
    t1.join();
    t2.join();
    
    std::cout << "i=" << i << std::endl;
}

测试代码如上所示，执行 g++ -std=c++20 -O0 -pthread main.cpp && ./a.out 10 命令编译并运行得到结果 i=20，貌似很正常，一共两个线程，每个线程执行10次自增操作，结果就应该是20啊，先别太早下结论，增大自增范围试试。

执行 g++ -std=c++20 -O0 -pthread main.cpp && ./a.out 100000 得到结果 i=112831，多次执行发现每次运行结果都不太一样，但是数据范围在 100000~200000，这就有些奇怪了，每个线程执行循环执行一条语句，那么程序结果应该等于 2n 才对，为什么结果总是小于 2n 呢，难道有些循环没有执行？

其实不是这样的，i++从C++语言的层面来看确实是一条语句，但是真正再和机器打交道时一般会解释成类似于下面这样3条汇编指令：

        // x86 msvc v19.latest
        mov     eax, DWORD PTR _i$[ebp]
        add     eax, 1
        mov     DWORD PTR _i$[ebp], eax

3条指令的含义可以理解为读取、自增，设置共三步，既然不是真正的一条语句，那么在多线的环境下就会生语句的交叉执行，比如第一个线程执行读取变量i的值之后，第二个线程也读取了变量i的值，这样两个线程都进行后续的自增和设置指令后，会发现比预期的值少了一个，这种情况在循环次数较多时尤为明显。

通过加锁把自增变为原子操作

既然每个自增操作可能会被分解成3条指令，那么我们可以加锁来将3条指令捆绑，当一个线程执行自增操作时加锁来防止其他进程“捣乱”，具体修改如下，可以在自增操作前直接加锁：

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

int i = 0;
std::mutex mt;

void inc()
{
    std::lock_guard<std::mutex> l(mt);
    i++; 
}

void func(int n)
{
    for (int k = 0; k < n; k++) inc();
}

int main(int argc, char* argv[])
{
    int n = argc > 1 ? atoi(argv[1]) : 100;
    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
    
    std::thread t1(func, n);
    std::thread t2(func, n);
    
    t1.join();
    t2.join();
    
    std::cout << "i=" << i << std::endl;
    std::chrono::duration<double> duration_cost = std::chrono::duration_cast<
        std::chrono::duration<double> >(std::chrono::steady_clock::now() - start);
    std::cout <<  "total cost " << duration_cost.count() << " seconds." << std::endl;
    
    return 0;
}

执行 g++ -std=c++20 -O0 -pthread main.cpp && ./a.out 10000000 命令后运行结果如下：

i=20000000
total cost 2.39123 seconds.

通过加锁，我们已经保证了结果的正确性，但是我们知道加锁的额外消耗还是很大的，有没有其他的方式来实现原子操作呢？

使用atomic来保证自增的原子性

其实在C++11之前可以通过嵌入汇编指令来实现，不过自从C++11引入atomic之后，类似的需求变得简单了许多，可以直接使用autmic这个模板类来实现，代码几乎不需要修改，只需将变量 i 改为 atomic<int> 类型，再把锁去掉就可以了，修改后的代码如下：

#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
#include <atomic>

std::atomic<int> i = 0; // int -> atomic<int>
std::mutex mt;

void inc()
{
    //std::lock_guard<std::mutex> l(mt);  //remove lock
    i++; 
}

void func(int n)
{
    for (int k = 0; k < n; k++) inc();
}

int main(int argc, char* argv[])
{
    int n = argc > 1 ? atoi(argv[1]) : 100;
    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
    
    std::thread t1(func, n);
    std::thread t2(func, n);
    
    t1.join();
    t2.join();
    
    std::cout << "i=" << i << std::endl;
    std::chrono::duration<double> duration_cost = std::chrono::duration_cast<
        std::chrono::duration<double> >(std::chrono::steady_clock::now() - start);
    std::cout <<  "total cost " << duration_cost.count() << " seconds." << std::endl;
    
    return 0;
}