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

 编写测试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;
}

运行效果如下：

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

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