C++原子操作和互斥锁性能（速度）对比

最新推荐文章于 2025-06-03 18:51:41 发布

原创最新推荐文章于 2025-06-03 18:51:41 发布 · 3.5k 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#c++

C++ 专栏收录该内容

20 篇文章

订阅专栏

本文通过对比测试展示了在多线程环境下，原子操作与互斥锁在保证数据一致性上的差异。在没有同步措施的情况下，临界资源的值不正确。使用原子操作虽然提高了执行效率，但耗时仍长于无保护的情况。而互斥锁虽然保证了数据正确性，但执行时间显著增加。这表明在性能和正确性之间需要权衡选择。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先说结论：原子操作性能（速度）强于互斥锁，下面用例子进行说明。

编写测试demo，开启两个线程，对全局变量n分别进行自增、自减操作，计算执行时间。

首先看没有用任何手段进行互斥的情况，用文章《C++计算打印函数和代码块的执行时间（支持所有类型函数）》中的方法进行时间测量：

#include <atomic>
#include <thread>
#include <chrono>
#include <memory>
#include <future>
#include <functional>
#include <iostream>

using namespace std;
#define TOTAL 100000000
int n = 0;


template<class T, class... Args>
auto measure(T&& func, Args&&... args)->std::future<typename std::result_of<T(Args...)>::type>
{
    using return_type = typename std::result_of<T(Args...)>::type;
    auto task = std::make_shared<std::packaged_task<return_type()>>
        (std::bind(std::forward<T>(func), std::forward<Args>(args)...));
    std::future<return_type> res = task->get_future();
    auto begin = std::chrono::high_resolution_clock::now();
    (*task)();
    auto end = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
    printf("执行时间: % .3f seconds.\n", elapsed.count() * 1e-9);
    return res;
}


void funPlus()
{
    for (int i = 0; i < TOTAL; i++)
    {
        n++;
    }
}

void funMinus()
{
    for (int i = 0; i < TOTAL; i++)
    {
        n--;
    }
}

int main()
{
    measure([] {
        thread a(funPlus);
        thread b(funMinus);
        a.join();
        b.join();
        });

    cout << "执行结束，n的值为： " << n << endl;
	return 0;
}

运行结果如下：

执行时间是0.541秒，是耗时最短的，但是由于没有用互斥方法保护，所以临界资源n的值不正确（正确的值应该为0）。这是因为自增、自减操作不是原子的，编译得到的汇编指令可能会对应多条指令。所以我们得要对n这个临界资源进行互斥保护。

我们来看下使用原子操作std::atomic

#include <atomic>
#include <thread>
#include <chrono>
#include <memory>
#include <future>
#include <functional>
#include <iostream>

using namespace std;
#define TOTAL 100000000
atomic<int> n(0);


template<class T, class... Args>
auto measure(T&& func, Args&&... args)->std::future<typename std::result_of<T(Args...)>::type>
{
    using return_type = typename std::result_of<T(Args...)>::type;
    auto task = std::make_shared<std::packaged_task<return_type()>>
        (std::bind(std::forward<T>(func), std::forward<Args>(args)...));
    std::future<return_type> res = task->get_future();
    auto begin = std::chrono::high_resolution_clock::now();
    (*task)();
    auto end = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
    printf("执行时间: % .3f seconds.\n", elapsed.count() * 1e-9);
    return res;
}


void funPlus()
{
    for (int i = 0; i < TOTAL; i++)
    {
        n++;
    }
}

void funMinus()
{
    for (int i = 0; i < TOTAL; i++)
    {
        n--;
    }
}

int main()
{
    measure([] {
        thread a(funPlus);
        thread b(funMinus);
        a.join();
        b.join();
        });

    cout << "执行结束，n的值为： " << n << endl;
	return 0;
}

执行效果如下：

可以看到耗时为：5.261秒，n的值为0。也就是说耗时变长了，但是临界资源n的值可以保证一定正确。

我们再来看使用互斥锁的情况：

#include <atomic>
#include <thread>
#include <chrono>
#include <memory>
#include <future>
#include <functional>
#include <iostream>
#include <mutex>

using namespace std;
#define TOTAL 100000000
std::mutex g_mutex;
int n = 0;


template<class T, class... Args>
auto measure(T&& func, Args&&... args)->std::future<typename std::result_of<T(Args...)>::type>
{
    using return_type = typename std::result_of<T(Args...)>::type;
    auto task = std::make_shared<std::packaged_task<return_type()>>
        (std::bind(std::forward<T>(func), std::forward<Args>(args)...));
    std::future<return_type> res = task->get_future();
    auto begin = std::chrono::high_resolution_clock::now();
    (*task)();
    auto end = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
    printf("执行时间: % .3f seconds.\n", elapsed.count() * 1e-9);
    return res;
}


void funPlus()
{
    for (int i = 0; i < TOTAL; i++)
    {
        std::lock_guard<std::mutex> lock(g_mutex);
        n++;
    }
}

void funMinus()
{
    for (int i = 0; i < TOTAL; i++)
    {
        std::lock_guard<std::mutex> lock(g_mutex);
        n--;
    }
}

int main()
{
    measure([] {
        thread a(funPlus);
        thread b(funMinus);
        a.join();
        b.join();
        });

    cout << "执行结束，n的值为： " << n << endl;
	return 0;
}

运行效果如下：