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

冷不防 2022-08-28 07:53 190阅读 0赞

### 文章目录 ###

*  前言
 *  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;
    }

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

i=20000000
    total cost 1.6554 seconds.

通过对比可以发现，使用 `std::atomic` 模板类之后，在保证了结果正确的同时，相比于加锁实现原子性速度上有了明显的提升。

# 总结 #

*  `ACID` 是指事务管理中的原子性，一致性，隔离性和持久性4个特性。
 *  加锁（写锁）的目的通常是将可能同时发生的操作串行化，以此来避免对资源的竞争出现问题
 *  操作的并行加快了任务的处理速度，而“加锁”使部分操作回归到串行，两者相互配合是为了在**更短**的时间内得到**正确**的结果
 *  `std::atomic` 降低了原子性操作编程的难度，同时相比于加锁实现原子性还有了性能的提升

--------------------

[ ==>> 反爬链接，请勿点击，原地爆炸，概不负责！<<== ][_ _]

--------------------

> 时光时光慢些吧，不要再让你变老了，我愿用我一切，换你岁月长留~
> 
> > 时间对于每个人来说，都是公平的，真的是这样吗？我觉得未必吧！

[_ _]: https://blog.csdn.net/albertsh/article/details/120245600