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

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

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

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

#include 
#include#include#include#include#include#includeusing namespace std;
#define TOTAL 100000000
int n = 0;


templateauto measure(T&& func, Args&&... args)->std::future::type>{
    using return_type = typename std::result_of::type;
    auto task = std::make_shared>(std::bind(std::forward(func), std::forward(args)...));
    std::futureres = 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(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 
#include#include#include#include#include#includeusing namespace std;
#define TOTAL 100000000
atomicn(0);


templateauto measure(T&& func, Args&&... args)->std::future::type>{
    using return_type = typename std::result_of::type;
    auto task = std::make_shared>(std::bind(std::forward(func), std::forward(args)...));
    std::futureres = 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(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 
#include#include#include#include#include#include#includeusing namespace std;
#define TOTAL 100000000
std::mutex g_mutex;
int n = 0;


templateauto measure(T&& func, Args&&... args)->std::future::type>{
    using return_type = typename std::result_of::type;
    auto task = std::make_shared>(std::bind(std::forward(func), std::forward(args)...));
    std::futureres = 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(end - begin);
    printf("执行时间: % .3f seconds.\n", elapsed.count() * 1e-9);
    return res;
}


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

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

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

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

运行效果如下：

可以看到执行时间为27.762秒。执行时间最长，但也能保持临界资源n的值正确。

所以对于基本类型的临界资源，我们进行访问时可以用原子操作代替互斥锁，来提高性能。

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧